Mercurial > vim
annotate src/diff.c @ 32721:94f4a488412e v9.0.1683
Updated runtime files
Commit: https://github.com/vim/vim/commit/6efb1980336ff324e9c57a4e282530b952fca816
Author: Christian Brabandt <cb@256bit.org>
Date: Thu Aug 10 05:44:25 2023 +0200
Updated runtime files
This is a collection of various PRs from github that all require a minor
patch number:
1) https://github.com/vim/vim/pull/12612
Do not conflate dictionary key with end of block
2) https://github.com/vim/vim/pull/12729:
When saving and restoring 'undolevels', the constructs `&undolevels` and
`:set undolevels` are problematic.
The construct `&undolevels` reads an unpredictable value; it will be the
local option value (if one has been set), or the global option value
(otherwise), making it unsuitable for saving a value for later
restoration.
Similarly, if a local option value has been set for 'undolevels',
temporarily modifying the option via `:set undolevels` changes the local
value as well as the global value, requiring extra work to restore both
values.
Saving and restoring the option value in one step via the construct
`:let &undolevels = &undolevels` appears to make no changes to the
'undolevels' option, but if a local option has been set to a different
value than the global option, it has the unintended effect of changing
the global 'undolevels' value to the local value.
Update the documentation to explain these issues and recommend explicit
use of global and local option values when saving and restoring. Update
some unit tests to use `g:undolevels`.
3) https://github.com/vim/vim/pull/12702:
Problem: Pip requirements files are not recognized.
Solution: Add a pattern to match pip requirements files.
4) https://github.com/vim/vim/pull/12688:
Add indent file and tests for ABB Rapid
5) https://github.com/vim/vim/pull/12668:
Use Lua 5.1 numeric escapes in tests and add to CI
Only Lua 5.2+ and LuaJIT understand hexadecimal escapes in strings. Lua
5.1 only supports decimal escapes:
> A character in a string can also be specified by its numerical value
> using the escape sequence \ddd, where ddd is a sequence of up to three
> decimal digits. (Note that if a numerical escape is to be followed by a
> digit, it must be expressed using exactly three digits.) Strings in Lua
> can contain any 8-bit value, including embedded zeros, which can be
> specified as '\0'.
To make sure this works with Lua 5.4 and Lua 5.1 change the Vim CI to
run with Lua 5.1 as well as Lua 5.4
6) https://github.com/vim/vim/pull/12631:
Add hurl filetype detection
7) https://github.com/vim/vim/pull/12573:
Problem: Files for haskell persistent library are not recognized
Solution: Add pattern persistentmodels for haskell persistent library
closes: #12612
closes: #12729
closes: #12702
closes: #12688
closes: #12668
closes: #12631
closes: #12573
Co-authored-by: lacygoill <lacygoill@lacygoill.me>
Co-authored-by: Michael Henry <drmikehenry@drmikehenry.com>
Co-authored-by: ObserverOfTime <chronobserver@disroot.org>
Co-authored-by: KnoP-01 <knosowski@graeffrobotics.de>
Co-authored-by: James McCoy <jamessan@jamessan.com>
Co-authored-by: Jacob Pfeifer <jacob@pfeifer.dev>
Co-authored-by: Borys Lykah <lykahb@fastmail.com>
author | Christian Brabandt <cb@256bit.org> |
---|---|
date | Thu, 10 Aug 2023 06:30:06 +0200 |
parents | 9c6bc59b6d80 |
children | 95db67c7b754 |
rev | line source |
---|---|
10042
4aead6a9b7a9
commit https://github.com/vim/vim/commit/edf3f97ae2af024708ebb4ac614227327033ca47
Christian Brabandt <cb@256bit.org>
parents:
10013
diff
changeset
|
1 /* vi:set ts=8 sts=4 sw=4 noet: |
7 | 2 * |
3 * VIM - Vi IMproved by Bram Moolenaar | |
4 * | |
5 * Do ":help uganda" in Vim to read copying and usage conditions. | |
6 * Do ":help credits" in Vim to see a list of people who contributed. | |
7 * See README.txt for an overview of the Vim source code. | |
8 */ | |
9 | |
10 /* | |
1788 | 11 * diff.c: code for diff'ing two, three or four buffers. |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
12 * |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
13 * There are three ways to diff: |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
14 * - Shell out to an external diff program, using files. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
15 * - Use the compiled-in xdiff library. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
16 * - Let 'diffexpr' do the work, using files. |
7 | 17 */ |
18 | |
19 #include "vim.h" | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
20 #include "xdiff/xdiff.h" |
7 | 21 |
22 #if defined(FEAT_DIFF) || defined(PROTO) | |
23 | |
14776
09c1f241e2f7
patch 8.1.0400: using freed memory with :diffget
Christian Brabandt <cb@256bit.org>
parents:
14770
diff
changeset
|
24 static int diff_busy = FALSE; // using diff structs, don't change them |
09c1f241e2f7
patch 8.1.0400: using freed memory with :diffget
Christian Brabandt <cb@256bit.org>
parents:
14770
diff
changeset
|
25 static int diff_need_update = FALSE; // ex_diffupdate needs to be called |
7 | 26 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
27 // flags obtained from the 'diffopt' option |
14762
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
28 #define DIFF_FILLER 0x001 // display filler lines |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
29 #define DIFF_IBLANK 0x002 // ignore empty lines |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
30 #define DIFF_ICASE 0x004 // ignore case |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
31 #define DIFF_IWHITE 0x008 // ignore change in white space |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
32 #define DIFF_IWHITEALL 0x010 // ignore all white space changes |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
33 #define DIFF_IWHITEEOL 0x020 // ignore change in white space at EOL |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
34 #define DIFF_HORIZONTAL 0x040 // horizontal splits |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
35 #define DIFF_VERTICAL 0x080 // vertical splits |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
36 #define DIFF_HIDDEN_OFF 0x100 // diffoff when hidden |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
37 #define DIFF_INTERNAL 0x200 // use internal xdiff algorithm |
18590
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
38 #define DIFF_CLOSE_OFF 0x400 // diffoff when closing window |
23895
e313b6ee2d9c
patch 8.2.2490: 'wrap' option is always reset when starting diff mode
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
39 #define DIFF_FOLLOWWRAP 0x800 // follow the wrap option |
14762
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
40 #define ALL_WHITE_DIFF (DIFF_IWHITE | DIFF_IWHITEALL | DIFF_IWHITEEOL) |
18590
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
41 static int diff_flags = DIFF_INTERNAL | DIFF_FILLER | DIFF_CLOSE_OFF; |
7 | 42 |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
43 static long diff_algorithm = 0; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
44 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
45 #define LBUFLEN 50 // length of line in diff file |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
46 |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
47 static int diff_a_works = MAYBE; // TRUE when "diff -a" works, FALSE when it |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
48 // doesn't work, MAYBE when not checked yet |
8212
05b88224cea1
commit https://github.com/vim/vim/commit/48e330aff911be1c798c88a973af6437a8141fce
Christian Brabandt <cb@256bit.org>
parents:
7817
diff
changeset
|
49 #if defined(MSWIN) |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
50 static int diff_bin_works = MAYBE; // TRUE when "diff --binary" works, FALSE |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
51 // when it doesn't work, MAYBE when not |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
52 // checked yet |
7 | 53 #endif |
54 | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
55 // used for diff input |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
56 typedef struct { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
57 char_u *din_fname; // used for external diff |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
58 mmfile_t din_mmfile; // used for internal diff |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
59 } diffin_T; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
60 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
61 // used for diff result |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
62 typedef struct { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
63 char_u *dout_fname; // used for external diff |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
64 garray_T dout_ga; // used for internal diff |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
65 } diffout_T; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
66 |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
67 // used for recording hunks from xdiff |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
68 typedef struct { |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
69 linenr_T lnum_orig; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
70 long count_orig; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
71 linenr_T lnum_new; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
72 long count_new; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
73 } diffhunk_T; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
74 |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
75 // two diff inputs and one result |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
76 typedef struct { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
77 diffin_T dio_orig; // original file input |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
78 diffin_T dio_new; // new file input |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
79 diffout_T dio_diff; // diff result |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
80 int dio_internal; // using internal diff |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
81 } diffio_T; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
82 |
7799
af3c41a3c53f
commit https://github.com/vim/vim/commit/f28dbcea371b3a35727d91afc90fb90e0527d78a
Christian Brabandt <cb@256bit.org>
parents:
7338
diff
changeset
|
83 static int diff_buf_idx(buf_T *buf); |
af3c41a3c53f
commit https://github.com/vim/vim/commit/f28dbcea371b3a35727d91afc90fb90e0527d78a
Christian Brabandt <cb@256bit.org>
parents:
7338
diff
changeset
|
84 static int diff_buf_idx_tp(buf_T *buf, tabpage_T *tp); |
af3c41a3c53f
commit https://github.com/vim/vim/commit/f28dbcea371b3a35727d91afc90fb90e0527d78a
Christian Brabandt <cb@256bit.org>
parents:
7338
diff
changeset
|
85 static void diff_mark_adjust_tp(tabpage_T *tp, int idx, linenr_T line1, linenr_T line2, long amount, long amount_after); |
af3c41a3c53f
commit https://github.com/vim/vim/commit/f28dbcea371b3a35727d91afc90fb90e0527d78a
Christian Brabandt <cb@256bit.org>
parents:
7338
diff
changeset
|
86 static void diff_check_unchanged(tabpage_T *tp, diff_T *dp); |
af3c41a3c53f
commit https://github.com/vim/vim/commit/f28dbcea371b3a35727d91afc90fb90e0527d78a
Christian Brabandt <cb@256bit.org>
parents:
7338
diff
changeset
|
87 static int diff_check_sanity(tabpage_T *tp, diff_T *dp); |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
88 static int check_external_diff(diffio_T *diffio); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
89 static int diff_file(diffio_T *diffio); |
7799
af3c41a3c53f
commit https://github.com/vim/vim/commit/f28dbcea371b3a35727d91afc90fb90e0527d78a
Christian Brabandt <cb@256bit.org>
parents:
7338
diff
changeset
|
90 static int diff_equal_entry(diff_T *dp, int idx1, int idx2); |
af3c41a3c53f
commit https://github.com/vim/vim/commit/f28dbcea371b3a35727d91afc90fb90e0527d78a
Christian Brabandt <cb@256bit.org>
parents:
7338
diff
changeset
|
91 static int diff_cmp(char_u *s1, char_u *s2); |
7 | 92 #ifdef FEAT_FOLDING |
7799
af3c41a3c53f
commit https://github.com/vim/vim/commit/f28dbcea371b3a35727d91afc90fb90e0527d78a
Christian Brabandt <cb@256bit.org>
parents:
7338
diff
changeset
|
93 static void diff_fold_update(diff_T *dp, int skip_idx); |
7 | 94 #endif |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
95 static void diff_read(int idx_orig, int idx_new, diffio_T *dio); |
7799
af3c41a3c53f
commit https://github.com/vim/vim/commit/f28dbcea371b3a35727d91afc90fb90e0527d78a
Christian Brabandt <cb@256bit.org>
parents:
7338
diff
changeset
|
96 static void diff_copy_entry(diff_T *dprev, diff_T *dp, int idx_orig, int idx_new); |
af3c41a3c53f
commit https://github.com/vim/vim/commit/f28dbcea371b3a35727d91afc90fb90e0527d78a
Christian Brabandt <cb@256bit.org>
parents:
7338
diff
changeset
|
97 static diff_T *diff_alloc_new(tabpage_T *tp, diff_T *dprev, diff_T *dp); |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
98 static int parse_diff_ed(char_u *line, diffhunk_T *hunk); |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
99 static int parse_diff_unified(char_u *line, diffhunk_T *hunk); |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
100 static int xdiff_out(long start_a, long count_a, long start_b, long count_b, void *priv); |
7 | 101 |
19888
435726a03481
patch 8.2.0500: using the same loop in many places
Bram Moolenaar <Bram@vim.org>
parents:
18777
diff
changeset
|
102 #define FOR_ALL_DIFFBLOCKS_IN_TAB(tp, dp) \ |
435726a03481
patch 8.2.0500: using the same loop in many places
Bram Moolenaar <Bram@vim.org>
parents:
18777
diff
changeset
|
103 for ((dp) = (tp)->tp_first_diff; (dp) != NULL; (dp) = (dp)->df_next) |
435726a03481
patch 8.2.0500: using the same loop in many places
Bram Moolenaar <Bram@vim.org>
parents:
18777
diff
changeset
|
104 |
7 | 105 /* |
106 * Called when deleting or unloading a buffer: No longer make a diff with it. | |
107 */ | |
108 void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
109 diff_buf_delete(buf_T *buf) |
7 | 110 { |
111 int i; | |
672 | 112 tabpage_T *tp; |
7 | 113 |
9649
fd9727ae3c49
commit https://github.com/vim/vim/commit/2932359000b2f918d5fade79ea4d124d5943cd07
Christian Brabandt <cb@256bit.org>
parents:
9487
diff
changeset
|
114 FOR_ALL_TABPAGES(tp) |
7 | 115 { |
672 | 116 i = diff_buf_idx_tp(buf, tp); |
117 if (i != DB_COUNT) | |
118 { | |
119 tp->tp_diffbuf[i] = NULL; | |
120 tp->tp_diff_invalid = TRUE; | |
1761 | 121 if (tp == curtab) |
29293
bf4d7898cf93
patch 8.2.5163: crash when deleting buffers in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
28457
diff
changeset
|
122 { |
bf4d7898cf93
patch 8.2.5163: crash when deleting buffers in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
28457
diff
changeset
|
123 // don't redraw right away, more might change or buffer state |
bf4d7898cf93
patch 8.2.5163: crash when deleting buffers in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
28457
diff
changeset
|
124 // is invalid right now |
bf4d7898cf93
patch 8.2.5163: crash when deleting buffers in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
28457
diff
changeset
|
125 need_diff_redraw = TRUE; |
29732
89e1d67814a9
patch 9.0.0206: redraw flags are not named specifically
Bram Moolenaar <Bram@vim.org>
parents:
29566
diff
changeset
|
126 redraw_later(UPD_VALID); |
29293
bf4d7898cf93
patch 8.2.5163: crash when deleting buffers in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
28457
diff
changeset
|
127 } |
672 | 128 } |
7 | 129 } |
130 } | |
131 | |
132 /* | |
16 | 133 * Check if the current buffer should be added to or removed from the list of |
134 * diff buffers. | |
135 */ | |
136 void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
137 diff_buf_adjust(win_T *win) |
16 | 138 { |
139 win_T *wp; | |
672 | 140 int i; |
16 | 141 |
142 if (!win->w_p_diff) | |
143 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
144 // When there is no window showing a diff for this buffer, remove |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
145 // it from the diffs. |
9649
fd9727ae3c49
commit https://github.com/vim/vim/commit/2932359000b2f918d5fade79ea4d124d5943cd07
Christian Brabandt <cb@256bit.org>
parents:
9487
diff
changeset
|
146 FOR_ALL_WINDOWS(wp) |
16 | 147 if (wp->w_buffer == win->w_buffer && wp->w_p_diff) |
148 break; | |
149 if (wp == NULL) | |
672 | 150 { |
151 i = diff_buf_idx(win->w_buffer); | |
152 if (i != DB_COUNT) | |
153 { | |
154 curtab->tp_diffbuf[i] = NULL; | |
155 curtab->tp_diff_invalid = TRUE; | |
1761 | 156 diff_redraw(TRUE); |
672 | 157 } |
158 } | |
16 | 159 } |
160 else | |
161 diff_buf_add(win->w_buffer); | |
162 } | |
163 | |
164 /* | |
7 | 165 * Add a buffer to make diffs for. |
672 | 166 * Call this when a new buffer is being edited in the current window where |
167 * 'diff' is set. | |
1788 | 168 * Marks the current buffer as being part of the diff and requiring updating. |
672 | 169 * This must be done before any autocmd, because a command may use info |
170 * about the screen contents. | |
7 | 171 */ |
172 void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
173 diff_buf_add(buf_T *buf) |
7 | 174 { |
175 int i; | |
176 | |
177 if (diff_buf_idx(buf) != DB_COUNT) | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
178 return; // It's already there. |
7 | 179 |
180 for (i = 0; i < DB_COUNT; ++i) | |
672 | 181 if (curtab->tp_diffbuf[i] == NULL) |
7 | 182 { |
672 | 183 curtab->tp_diffbuf[i] = buf; |
184 curtab->tp_diff_invalid = TRUE; | |
1761 | 185 diff_redraw(TRUE); |
7 | 186 return; |
187 } | |
188 | |
26602
fac6673086df
patch 8.2.3830: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26044
diff
changeset
|
189 semsg(_(e_cannot_diff_more_than_nr_buffers), DB_COUNT); |
7 | 190 } |
191 | |
192 /* | |
10821
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
193 * Remove all buffers to make diffs for. |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
194 */ |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
195 static void |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
196 diff_buf_clear(void) |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
197 { |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
198 int i; |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
199 |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
200 for (i = 0; i < DB_COUNT; ++i) |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
201 if (curtab->tp_diffbuf[i] != NULL) |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
202 { |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
203 curtab->tp_diffbuf[i] = NULL; |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
204 curtab->tp_diff_invalid = TRUE; |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
205 diff_redraw(TRUE); |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
206 } |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
207 } |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
208 |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
209 /* |
672 | 210 * Find buffer "buf" in the list of diff buffers for the current tab page. |
7 | 211 * Return its index or DB_COUNT if not found. |
212 */ | |
213 static int | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
214 diff_buf_idx(buf_T *buf) |
7 | 215 { |
216 int idx; | |
217 | |
218 for (idx = 0; idx < DB_COUNT; ++idx) | |
672 | 219 if (curtab->tp_diffbuf[idx] == buf) |
220 break; | |
221 return idx; | |
222 } | |
223 | |
224 /* | |
225 * Find buffer "buf" in the list of diff buffers for tab page "tp". | |
226 * Return its index or DB_COUNT if not found. | |
227 */ | |
228 static int | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
229 diff_buf_idx_tp(buf_T *buf, tabpage_T *tp) |
672 | 230 { |
231 int idx; | |
232 | |
233 for (idx = 0; idx < DB_COUNT; ++idx) | |
234 if (tp->tp_diffbuf[idx] == buf) | |
7 | 235 break; |
236 return idx; | |
237 } | |
238 | |
239 /* | |
672 | 240 * Mark the diff info involving buffer "buf" as invalid, it will be updated |
241 * when info is requested. | |
7 | 242 */ |
243 void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
244 diff_invalidate(buf_T *buf) |
7 | 245 { |
672 | 246 tabpage_T *tp; |
247 int i; | |
248 | |
9649
fd9727ae3c49
commit https://github.com/vim/vim/commit/2932359000b2f918d5fade79ea4d124d5943cd07
Christian Brabandt <cb@256bit.org>
parents:
9487
diff
changeset
|
249 FOR_ALL_TABPAGES(tp) |
7 | 250 { |
672 | 251 i = diff_buf_idx_tp(buf, tp); |
252 if (i != DB_COUNT) | |
253 { | |
254 tp->tp_diff_invalid = TRUE; | |
255 if (tp == curtab) | |
256 diff_redraw(TRUE); | |
257 } | |
7 | 258 } |
259 } | |
260 | |
261 /* | |
672 | 262 * Called by mark_adjust(): update line numbers in "curbuf". |
7 | 263 */ |
264 void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
265 diff_mark_adjust( |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
266 linenr_T line1, |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
267 linenr_T line2, |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
268 long amount, |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
269 long amount_after) |
7 | 270 { |
672 | 271 int idx; |
272 tabpage_T *tp; | |
273 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
274 // Handle all tab pages that use the current buffer in a diff. |
9649
fd9727ae3c49
commit https://github.com/vim/vim/commit/2932359000b2f918d5fade79ea4d124d5943cd07
Christian Brabandt <cb@256bit.org>
parents:
9487
diff
changeset
|
275 FOR_ALL_TABPAGES(tp) |
672 | 276 { |
277 idx = diff_buf_idx_tp(curbuf, tp); | |
278 if (idx != DB_COUNT) | |
279 diff_mark_adjust_tp(tp, idx, line1, line2, amount, amount_after); | |
280 } | |
281 } | |
282 | |
283 /* | |
284 * Update line numbers in tab page "tp" for "curbuf" with index "idx". | |
285 * This attempts to update the changes as much as possible: | |
286 * When inserting/deleting lines outside of existing change blocks, create a | |
287 * new change block and update the line numbers in following blocks. | |
288 * When inserting/deleting lines in existing change blocks, update them. | |
289 */ | |
290 static void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
291 diff_mark_adjust_tp( |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
292 tabpage_T *tp, |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
293 int idx, |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
294 linenr_T line1, |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
295 linenr_T line2, |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
296 long amount, |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
297 long amount_after) |
672 | 298 { |
7 | 299 diff_T *dp; |
300 diff_T *dprev; | |
301 diff_T *dnext; | |
302 int i; | |
303 int inserted, deleted; | |
304 int n, off; | |
305 linenr_T last; | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
306 linenr_T lnum_deleted = line1; // lnum of remaining deletion |
7 | 307 int check_unchanged; |
308 | |
14764
f562b9fbd0d3
patch 8.1.0394: diffs are not always updated correctly
Christian Brabandt <cb@256bit.org>
parents:
14762
diff
changeset
|
309 if (diff_internal()) |
f562b9fbd0d3
patch 8.1.0394: diffs are not always updated correctly
Christian Brabandt <cb@256bit.org>
parents:
14762
diff
changeset
|
310 { |
14780
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
311 // Will update diffs before redrawing. Set _invalid to update the |
14764
f562b9fbd0d3
patch 8.1.0394: diffs are not always updated correctly
Christian Brabandt <cb@256bit.org>
parents:
14762
diff
changeset
|
312 // diffs themselves, set _update to also update folds properly just |
f562b9fbd0d3
patch 8.1.0394: diffs are not always updated correctly
Christian Brabandt <cb@256bit.org>
parents:
14762
diff
changeset
|
313 // before redrawing. |
14972
5d52b21b2e7f
patch 8.1.0497: :%diffput changes order of lines
Bram Moolenaar <Bram@vim.org>
parents:
14893
diff
changeset
|
314 // Do update marks here, it is needed for :%diffput. |
14764
f562b9fbd0d3
patch 8.1.0394: diffs are not always updated correctly
Christian Brabandt <cb@256bit.org>
parents:
14762
diff
changeset
|
315 tp->tp_diff_invalid = TRUE; |
f562b9fbd0d3
patch 8.1.0394: diffs are not always updated correctly
Christian Brabandt <cb@256bit.org>
parents:
14762
diff
changeset
|
316 tp->tp_diff_update = TRUE; |
f562b9fbd0d3
patch 8.1.0394: diffs are not always updated correctly
Christian Brabandt <cb@256bit.org>
parents:
14762
diff
changeset
|
317 } |
f562b9fbd0d3
patch 8.1.0394: diffs are not always updated correctly
Christian Brabandt <cb@256bit.org>
parents:
14762
diff
changeset
|
318 |
7 | 319 if (line2 == MAXLNUM) |
320 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
321 // mark_adjust(99, MAXLNUM, 9, 0): insert lines |
7 | 322 inserted = amount; |
323 deleted = 0; | |
324 } | |
325 else if (amount_after > 0) | |
326 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
327 // mark_adjust(99, 98, MAXLNUM, 9): a change that inserts lines |
7 | 328 inserted = amount_after; |
329 deleted = 0; | |
330 } | |
331 else | |
332 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
333 // mark_adjust(98, 99, MAXLNUM, -2): delete lines |
7 | 334 inserted = 0; |
335 deleted = -amount_after; | |
336 } | |
337 | |
338 dprev = NULL; | |
672 | 339 dp = tp->tp_first_diff; |
7 | 340 for (;;) |
341 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
342 // If the change is after the previous diff block and before the next |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
343 // diff block, thus not touching an existing change, create a new diff |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
344 // block. Don't do this when ex_diffgetput() is busy. |
7 | 345 if ((dp == NULL || dp->df_lnum[idx] - 1 > line2 |
346 || (line2 == MAXLNUM && dp->df_lnum[idx] > line1)) | |
347 && (dprev == NULL | |
348 || dprev->df_lnum[idx] + dprev->df_count[idx] < line1) | |
349 && !diff_busy) | |
350 { | |
672 | 351 dnext = diff_alloc_new(tp, dprev, dp); |
7 | 352 if (dnext == NULL) |
353 return; | |
354 | |
355 dnext->df_lnum[idx] = line1; | |
356 dnext->df_count[idx] = inserted; | |
357 for (i = 0; i < DB_COUNT; ++i) | |
672 | 358 if (tp->tp_diffbuf[i] != NULL && i != idx) |
7 | 359 { |
360 if (dprev == NULL) | |
361 dnext->df_lnum[i] = line1; | |
362 else | |
363 dnext->df_lnum[i] = line1 | |
364 + (dprev->df_lnum[i] + dprev->df_count[i]) | |
365 - (dprev->df_lnum[idx] + dprev->df_count[idx]); | |
366 dnext->df_count[i] = deleted; | |
367 } | |
368 } | |
369 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
370 // if at end of the list, quit |
7 | 371 if (dp == NULL) |
372 break; | |
373 | |
374 /* | |
375 * Check for these situations: | |
376 * 1 2 3 | |
377 * 1 2 3 | |
378 * line1 2 3 4 5 | |
379 * 2 3 4 5 | |
380 * 2 3 4 5 | |
381 * line2 2 3 4 5 | |
382 * 3 5 6 | |
383 * 3 5 6 | |
384 */ | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
385 // compute last line of this change |
7 | 386 last = dp->df_lnum[idx] + dp->df_count[idx] - 1; |
387 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
388 // 1. change completely above line1: nothing to do |
7 | 389 if (last >= line1 - 1) |
390 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
391 // 6. change below line2: only adjust for amount_after; also when |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
392 // "deleted" became zero when deleted all lines between two diffs |
7 | 393 if (dp->df_lnum[idx] - (deleted + inserted != 0) > line2) |
394 { | |
395 if (amount_after == 0) | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
396 break; // nothing left to change |
7 | 397 dp->df_lnum[idx] += amount_after; |
398 } | |
399 else | |
400 { | |
401 check_unchanged = FALSE; | |
402 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
403 // 2. 3. 4. 5.: inserted/deleted lines touching this diff. |
7 | 404 if (deleted > 0) |
405 { | |
29295
92dd6fef5ace
patch 8.2.5164: invalid memory access after diff buffer manipulations
Bram Moolenaar <Bram@vim.org>
parents:
29293
diff
changeset
|
406 off = 0; |
7 | 407 if (dp->df_lnum[idx] >= line1) |
408 { | |
409 if (last <= line2) | |
410 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
411 // 4. delete all lines of diff |
7 | 412 if (dp->df_next != NULL |
413 && dp->df_next->df_lnum[idx] - 1 <= line2) | |
414 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
415 // delete continues in next diff, only do |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
416 // lines until that one |
7 | 417 n = dp->df_next->df_lnum[idx] - lnum_deleted; |
418 deleted -= n; | |
419 n -= dp->df_count[idx]; | |
420 lnum_deleted = dp->df_next->df_lnum[idx]; | |
421 } | |
422 else | |
423 n = deleted - dp->df_count[idx]; | |
424 dp->df_count[idx] = 0; | |
425 } | |
426 else | |
427 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
428 // 5. delete lines at or just before top of diff |
29295
92dd6fef5ace
patch 8.2.5164: invalid memory access after diff buffer manipulations
Bram Moolenaar <Bram@vim.org>
parents:
29293
diff
changeset
|
429 off = dp->df_lnum[idx] - lnum_deleted; |
7 | 430 n = off; |
431 dp->df_count[idx] -= line2 - dp->df_lnum[idx] + 1; | |
432 check_unchanged = TRUE; | |
433 } | |
434 dp->df_lnum[idx] = line1; | |
435 } | |
436 else | |
437 { | |
438 if (last < line2) | |
439 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
440 // 2. delete at end of diff |
7 | 441 dp->df_count[idx] -= last - lnum_deleted + 1; |
442 if (dp->df_next != NULL | |
443 && dp->df_next->df_lnum[idx] - 1 <= line2) | |
444 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
445 // delete continues in next diff, only do |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
446 // lines until that one |
7 | 447 n = dp->df_next->df_lnum[idx] - 1 - last; |
448 deleted -= dp->df_next->df_lnum[idx] | |
449 - lnum_deleted; | |
450 lnum_deleted = dp->df_next->df_lnum[idx]; | |
451 } | |
452 else | |
453 n = line2 - last; | |
454 check_unchanged = TRUE; | |
455 } | |
456 else | |
457 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
458 // 3. delete lines inside the diff |
7 | 459 n = 0; |
460 dp->df_count[idx] -= deleted; | |
461 } | |
462 } | |
463 | |
464 for (i = 0; i < DB_COUNT; ++i) | |
672 | 465 if (tp->tp_diffbuf[i] != NULL && i != idx) |
7 | 466 { |
29519
3afe997f4415
patch 9.0.0101: invalid memory access in diff mode with "dp" and undo
Bram Moolenaar <Bram@vim.org>
parents:
29367
diff
changeset
|
467 if (dp->df_lnum[i] > off) |
3afe997f4415
patch 9.0.0101: invalid memory access in diff mode with "dp" and undo
Bram Moolenaar <Bram@vim.org>
parents:
29367
diff
changeset
|
468 dp->df_lnum[i] -= off; |
3afe997f4415
patch 9.0.0101: invalid memory access in diff mode with "dp" and undo
Bram Moolenaar <Bram@vim.org>
parents:
29367
diff
changeset
|
469 else |
3afe997f4415
patch 9.0.0101: invalid memory access in diff mode with "dp" and undo
Bram Moolenaar <Bram@vim.org>
parents:
29367
diff
changeset
|
470 dp->df_lnum[i] = 1; |
7 | 471 dp->df_count[i] += n; |
472 } | |
473 } | |
474 else | |
475 { | |
476 if (dp->df_lnum[idx] <= line1) | |
477 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
478 // inserted lines somewhere in this diff |
7 | 479 dp->df_count[idx] += inserted; |
480 check_unchanged = TRUE; | |
481 } | |
482 else | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
483 // inserted lines somewhere above this diff |
7 | 484 dp->df_lnum[idx] += inserted; |
485 } | |
486 | |
487 if (check_unchanged) | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
488 // Check if inserted lines are equal, may reduce the |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
489 // size of the diff. TODO: also check for equal lines |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
490 // in the middle and perhaps split the block. |
672 | 491 diff_check_unchanged(tp, dp); |
7 | 492 } |
493 } | |
494 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
495 // check if this block touches the previous one, may merge them. |
7 | 496 if (dprev != NULL && dprev->df_lnum[idx] + dprev->df_count[idx] |
497 == dp->df_lnum[idx]) | |
498 { | |
499 for (i = 0; i < DB_COUNT; ++i) | |
672 | 500 if (tp->tp_diffbuf[i] != NULL) |
7 | 501 dprev->df_count[i] += dp->df_count[i]; |
502 dprev->df_next = dp->df_next; | |
503 vim_free(dp); | |
504 dp = dprev->df_next; | |
505 } | |
506 else | |
507 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
508 // Advance to next entry. |
7 | 509 dprev = dp; |
510 dp = dp->df_next; | |
511 } | |
512 } | |
513 | |
514 dprev = NULL; | |
672 | 515 dp = tp->tp_first_diff; |
7 | 516 while (dp != NULL) |
517 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
518 // All counts are zero, remove this entry. |
7 | 519 for (i = 0; i < DB_COUNT; ++i) |
672 | 520 if (tp->tp_diffbuf[i] != NULL && dp->df_count[i] != 0) |
7 | 521 break; |
522 if (i == DB_COUNT) | |
523 { | |
524 dnext = dp->df_next; | |
525 vim_free(dp); | |
526 dp = dnext; | |
527 if (dprev == NULL) | |
672 | 528 tp->tp_first_diff = dnext; |
7 | 529 else |
530 dprev->df_next = dnext; | |
531 } | |
532 else | |
533 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
534 // Advance to next entry. |
7 | 535 dprev = dp; |
536 dp = dp->df_next; | |
537 } | |
538 | |
539 } | |
672 | 540 |
541 if (tp == curtab) | |
542 { | |
17851
ba63a184e6b6
patch 8.1.1922: in diff mode global operations can be very slow
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
543 // Don't redraw right away, this updates the diffs, which can be slow. |
ba63a184e6b6
patch 8.1.1922: in diff mode global operations can be very slow
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
544 need_diff_redraw = TRUE; |
7 | 545 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
546 // Need to recompute the scroll binding, may remove or add filler |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
547 // lines (e.g., when adding lines above w_topline). But it's slow when |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
548 // making many changes, postpone until redrawing. |
672 | 549 diff_need_scrollbind = TRUE; |
550 } | |
7 | 551 } |
552 | |
553 /* | |
554 * Allocate a new diff block and link it between "dprev" and "dp". | |
555 */ | |
556 static diff_T * | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
557 diff_alloc_new(tabpage_T *tp, diff_T *dprev, diff_T *dp) |
7 | 558 { |
559 diff_T *dnew; | |
560 | |
16825
ce04ebdf26b8
patch 8.1.1414: alloc() returning "char_u *" causes a lot of type casts
Bram Moolenaar <Bram@vim.org>
parents:
16806
diff
changeset
|
561 dnew = ALLOC_ONE(diff_T); |
31667
b89cfd86e18e
patch 9.0.1166: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31531
diff
changeset
|
562 if (dnew == NULL) |
b89cfd86e18e
patch 9.0.1166: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31531
diff
changeset
|
563 return NULL; |
b89cfd86e18e
patch 9.0.1166: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31531
diff
changeset
|
564 |
b89cfd86e18e
patch 9.0.1166: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31531
diff
changeset
|
565 dnew->df_next = dp; |
b89cfd86e18e
patch 9.0.1166: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31531
diff
changeset
|
566 if (dprev == NULL) |
b89cfd86e18e
patch 9.0.1166: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31531
diff
changeset
|
567 tp->tp_first_diff = dnew; |
b89cfd86e18e
patch 9.0.1166: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31531
diff
changeset
|
568 else |
b89cfd86e18e
patch 9.0.1166: code is indented more than necessary
Bram Moolenaar <Bram@vim.org>
parents:
31531
diff
changeset
|
569 dprev->df_next = dnew; |
7 | 570 return dnew; |
571 } | |
572 | |
573 /* | |
574 * Check if the diff block "dp" can be made smaller for lines at the start and | |
575 * end that are equal. Called after inserting lines. | |
576 * This may result in a change where all buffers have zero lines, the caller | |
577 * must take care of removing it. | |
578 */ | |
579 static void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
580 diff_check_unchanged(tabpage_T *tp, diff_T *dp) |
7 | 581 { |
582 int i_org; | |
583 int i_new; | |
584 int off_org, off_new; | |
585 char_u *line_org; | |
586 int dir = FORWARD; | |
587 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
588 // Find the first buffers, use it as the original, compare the other |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
589 // buffer lines against this one. |
7 | 590 for (i_org = 0; i_org < DB_COUNT; ++i_org) |
672 | 591 if (tp->tp_diffbuf[i_org] != NULL) |
7 | 592 break; |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
593 if (i_org == DB_COUNT) // safety check |
7 | 594 return; |
595 | |
672 | 596 if (diff_check_sanity(tp, dp) == FAIL) |
7 | 597 return; |
598 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
599 // First check lines at the top, then at the bottom. |
7 | 600 off_org = 0; |
601 off_new = 0; | |
602 for (;;) | |
603 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
604 // Repeat until a line is found which is different or the number of |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
605 // lines has become zero. |
7 | 606 while (dp->df_count[i_org] > 0) |
607 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
608 // Copy the line, the next ml_get() will invalidate it. |
7 | 609 if (dir == BACKWARD) |
610 off_org = dp->df_count[i_org] - 1; | |
672 | 611 line_org = vim_strsave(ml_get_buf(tp->tp_diffbuf[i_org], |
7 | 612 dp->df_lnum[i_org] + off_org, FALSE)); |
613 if (line_org == NULL) | |
614 return; | |
615 for (i_new = i_org + 1; i_new < DB_COUNT; ++i_new) | |
616 { | |
672 | 617 if (tp->tp_diffbuf[i_new] == NULL) |
7 | 618 continue; |
619 if (dir == BACKWARD) | |
620 off_new = dp->df_count[i_new] - 1; | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
621 // if other buffer doesn't have this line, it was inserted |
7 | 622 if (off_new < 0 || off_new >= dp->df_count[i_new]) |
623 break; | |
672 | 624 if (diff_cmp(line_org, ml_get_buf(tp->tp_diffbuf[i_new], |
7 | 625 dp->df_lnum[i_new] + off_new, FALSE)) != 0) |
626 break; | |
627 } | |
628 vim_free(line_org); | |
629 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
630 // Stop when a line isn't equal in all diff buffers. |
7 | 631 if (i_new != DB_COUNT) |
632 break; | |
633 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
634 // Line matched in all buffers, remove it from the diff. |
7 | 635 for (i_new = i_org; i_new < DB_COUNT; ++i_new) |
672 | 636 if (tp->tp_diffbuf[i_new] != NULL) |
7 | 637 { |
638 if (dir == FORWARD) | |
639 ++dp->df_lnum[i_new]; | |
640 --dp->df_count[i_new]; | |
641 } | |
642 } | |
643 if (dir == BACKWARD) | |
644 break; | |
645 dir = BACKWARD; | |
646 } | |
647 } | |
648 | |
649 /* | |
650 * Check if a diff block doesn't contain invalid line numbers. | |
651 * This can happen when the diff program returns invalid results. | |
652 */ | |
653 static int | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
654 diff_check_sanity(tabpage_T *tp, diff_T *dp) |
7 | 655 { |
656 int i; | |
657 | |
658 for (i = 0; i < DB_COUNT; ++i) | |
672 | 659 if (tp->tp_diffbuf[i] != NULL) |
7 | 660 if (dp->df_lnum[i] + dp->df_count[i] - 1 |
672 | 661 > tp->tp_diffbuf[i]->b_ml.ml_line_count) |
7 | 662 return FAIL; |
663 return OK; | |
664 } | |
665 | |
666 /* | |
672 | 667 * Mark all diff buffers in the current tab page for redraw. |
7 | 668 */ |
17851
ba63a184e6b6
patch 8.1.1922: in diff mode global operations can be very slow
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
669 void |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
670 diff_redraw( |
14764
f562b9fbd0d3
patch 8.1.0394: diffs are not always updated correctly
Christian Brabandt <cb@256bit.org>
parents:
14762
diff
changeset
|
671 int dofold) // also recompute the folds |
7 | 672 { |
673 win_T *wp; | |
25717
d3f992bc6ef8
patch 8.2.3394: filler lines are wrong when changing text in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
25709
diff
changeset
|
674 win_T *wp_other = NULL; |
26044
2e8226c03007
patch 8.2.3556: filler lines are incorrect for other window in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
25717
diff
changeset
|
675 int used_max_fill_other = FALSE; |
2e8226c03007
patch 8.2.3556: filler lines are incorrect for other window in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
25717
diff
changeset
|
676 int used_max_fill_curwin = FALSE; |
7 | 677 int n; |
678 | |
17851
ba63a184e6b6
patch 8.1.1922: in diff mode global operations can be very slow
Bram Moolenaar <Bram@vim.org>
parents:
16825
diff
changeset
|
679 need_diff_redraw = FALSE; |
9649
fd9727ae3c49
commit https://github.com/vim/vim/commit/2932359000b2f918d5fade79ea4d124d5943cd07
Christian Brabandt <cb@256bit.org>
parents:
9487
diff
changeset
|
680 FOR_ALL_WINDOWS(wp) |
29566
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
681 { |
29293
bf4d7898cf93
patch 8.2.5163: crash when deleting buffers in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
28457
diff
changeset
|
682 // when closing windows or wiping buffers skip invalid window |
29566
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
683 if (!wp->w_p_diff || !buf_valid(wp->w_buffer)) |
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
684 continue; |
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
685 |
29732
89e1d67814a9
patch 9.0.0206: redraw flags are not named specifically
Bram Moolenaar <Bram@vim.org>
parents:
29566
diff
changeset
|
686 redraw_win_later(wp, UPD_SOME_VALID); |
29566
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
687 if (wp != curwin) |
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
688 wp_other = wp; |
7 | 689 #ifdef FEAT_FOLDING |
29566
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
690 if (dofold && foldmethodIsDiff(wp)) |
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
691 foldUpdateAll(wp); |
7 | 692 #endif |
29566
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
693 // A change may have made filler lines invalid, need to take care of |
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
694 // that for other windows. |
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
695 n = diff_check(wp, wp->w_topline); |
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
696 if ((wp != curwin && wp->w_topfill > 0) || n > 0) |
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
697 { |
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
698 if (wp->w_topfill > n) |
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
699 wp->w_topfill = (n < 0 ? 0 : n); |
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
700 else if (n > 0 && n > wp->w_topfill) |
7 | 701 { |
29566
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
702 wp->w_topfill = n; |
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
703 if (wp == curwin) |
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
704 used_max_fill_curwin = TRUE; |
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
705 else if (wp_other != NULL) |
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
706 used_max_fill_other = TRUE; |
7 | 707 } |
29566
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
708 check_topfill(wp, FALSE); |
7 | 709 } |
29566
99e3763cbd34
patch 9.0.0124: code has more indent than needed
Bram Moolenaar <Bram@vim.org>
parents:
29519
diff
changeset
|
710 } |
25717
d3f992bc6ef8
patch 8.2.3394: filler lines are wrong when changing text in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
25709
diff
changeset
|
711 |
26044
2e8226c03007
patch 8.2.3556: filler lines are incorrect for other window in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
25717
diff
changeset
|
712 if (wp_other != NULL && curwin->w_p_scb) |
2e8226c03007
patch 8.2.3556: filler lines are incorrect for other window in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
25717
diff
changeset
|
713 { |
2e8226c03007
patch 8.2.3556: filler lines are incorrect for other window in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
25717
diff
changeset
|
714 if (used_max_fill_curwin) |
26771
fc859aea8cec
patch 8.2.3914: various spelling mistakes in comments
Bram Moolenaar <Bram@vim.org>
parents:
26602
diff
changeset
|
715 // The current window was set to use the maximum number of filler |
26044
2e8226c03007
patch 8.2.3556: filler lines are incorrect for other window in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
25717
diff
changeset
|
716 // lines, may need to reduce them. |
2e8226c03007
patch 8.2.3556: filler lines are incorrect for other window in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
25717
diff
changeset
|
717 diff_set_topline(wp_other, curwin); |
2e8226c03007
patch 8.2.3556: filler lines are incorrect for other window in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
25717
diff
changeset
|
718 else if (used_max_fill_other) |
26771
fc859aea8cec
patch 8.2.3914: various spelling mistakes in comments
Bram Moolenaar <Bram@vim.org>
parents:
26602
diff
changeset
|
719 // The other window was set to use the maximum number of filler |
26044
2e8226c03007
patch 8.2.3556: filler lines are incorrect for other window in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
25717
diff
changeset
|
720 // lines, may need to reduce them. |
2e8226c03007
patch 8.2.3556: filler lines are incorrect for other window in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
25717
diff
changeset
|
721 diff_set_topline(curwin, wp_other); |
2e8226c03007
patch 8.2.3556: filler lines are incorrect for other window in diff mode
Bram Moolenaar <Bram@vim.org>
parents:
25717
diff
changeset
|
722 } |
7 | 723 } |
724 | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
725 static void |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
726 clear_diffin(diffin_T *din) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
727 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
728 if (din->din_fname == NULL) |
32120
97255d909654
patch 9.0.1391: "clear" macros are not always used
Bram Moolenaar <Bram@vim.org>
parents:
32118
diff
changeset
|
729 VIM_CLEAR(din->din_mmfile.ptr); |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
730 else |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
731 mch_remove(din->din_fname); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
732 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
733 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
734 static void |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
735 clear_diffout(diffout_T *dout) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
736 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
737 if (dout->dout_fname == NULL) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
738 ga_clear_strings(&dout->dout_ga); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
739 else |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
740 mch_remove(dout->dout_fname); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
741 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
742 |
7 | 743 /* |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
744 * Write buffer "buf" to a memory buffer. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
745 * Return FAIL for failure. |
7 | 746 */ |
747 static int | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
748 diff_write_buffer(buf_T *buf, diffin_T *din) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
749 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
750 linenr_T lnum; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
751 char_u *s; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
752 long len = 0; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
753 char_u *ptr; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
754 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
755 // xdiff requires one big block of memory with all the text. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
756 for (lnum = 1; lnum <= buf->b_ml.ml_line_count; ++lnum) |
14766
7a11facdf74b
patch 8.1.0395: compiler warning on 64-bit MS-Windows
Christian Brabandt <cb@256bit.org>
parents:
14764
diff
changeset
|
757 len += (long)STRLEN(ml_get_buf(buf, lnum, FALSE)) + 1; |
16768
695d9ef00b03
patch 8.1.1386: unessesary type casts for lalloc()
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
758 ptr = alloc(len); |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
759 if (ptr == NULL) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
760 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
761 // Allocating memory failed. This can happen, because we try to read |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
762 // the whole buffer text into memory. Set the failed flag, the diff |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
763 // will be retried with external diff. The flag is never reset. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
764 buf->b_diff_failed = TRUE; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
765 if (p_verbose > 0) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
766 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
767 verbose_enter(); |
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
15103
diff
changeset
|
768 smsg(_("Not enough memory to use internal diff for buffer \"%s\""), |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
769 buf->b_fname); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
770 verbose_leave(); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
771 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
772 return FAIL; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
773 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
774 din->din_mmfile.ptr = (char *)ptr; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
775 din->din_mmfile.size = len; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
776 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
777 len = 0; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
778 for (lnum = 1; lnum <= buf->b_ml.ml_line_count; ++lnum) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
779 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
780 for (s = ml_get_buf(buf, lnum, FALSE); *s != NUL; ) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
781 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
782 if (diff_flags & DIFF_ICASE) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
783 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
784 int c; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
785 int orig_len; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
786 char_u cbuf[MB_MAXBYTES + 1]; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
787 |
26794
83a99f08d1e8
patch 8.2.3925: diff mode confused by NUL bytes
Bram Moolenaar <Bram@vim.org>
parents:
26786
diff
changeset
|
788 if (*s == NL) |
83a99f08d1e8
patch 8.2.3925: diff mode confused by NUL bytes
Bram Moolenaar <Bram@vim.org>
parents:
26786
diff
changeset
|
789 c = NUL; |
83a99f08d1e8
patch 8.2.3925: diff mode confused by NUL bytes
Bram Moolenaar <Bram@vim.org>
parents:
26786
diff
changeset
|
790 else |
83a99f08d1e8
patch 8.2.3925: diff mode confused by NUL bytes
Bram Moolenaar <Bram@vim.org>
parents:
26786
diff
changeset
|
791 { |
83a99f08d1e8
patch 8.2.3925: diff mode confused by NUL bytes
Bram Moolenaar <Bram@vim.org>
parents:
26786
diff
changeset
|
792 // xdiff doesn't support ignoring case, fold-case the text. |
83a99f08d1e8
patch 8.2.3925: diff mode confused by NUL bytes
Bram Moolenaar <Bram@vim.org>
parents:
26786
diff
changeset
|
793 c = PTR2CHAR(s); |
83a99f08d1e8
patch 8.2.3925: diff mode confused by NUL bytes
Bram Moolenaar <Bram@vim.org>
parents:
26786
diff
changeset
|
794 c = MB_CASEFOLD(c); |
83a99f08d1e8
patch 8.2.3925: diff mode confused by NUL bytes
Bram Moolenaar <Bram@vim.org>
parents:
26786
diff
changeset
|
795 } |
18251
c8a53c0daeed
patch 8.1.2120: some MB_ macros are more complicated than necessary
Bram Moolenaar <Bram@vim.org>
parents:
17986
diff
changeset
|
796 orig_len = mb_ptr2len(s); |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
797 if (mb_char2bytes(c, cbuf) != orig_len) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
798 // TODO: handle byte length difference |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
799 mch_memmove(ptr + len, s, orig_len); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
800 else |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
801 mch_memmove(ptr + len, cbuf, orig_len); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
802 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
803 s += orig_len; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
804 len += orig_len; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
805 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
806 else |
26794
83a99f08d1e8
patch 8.2.3925: diff mode confused by NUL bytes
Bram Moolenaar <Bram@vim.org>
parents:
26786
diff
changeset
|
807 { |
83a99f08d1e8
patch 8.2.3925: diff mode confused by NUL bytes
Bram Moolenaar <Bram@vim.org>
parents:
26786
diff
changeset
|
808 ptr[len++] = *s == NL ? NUL : *s; |
83a99f08d1e8
patch 8.2.3925: diff mode confused by NUL bytes
Bram Moolenaar <Bram@vim.org>
parents:
26786
diff
changeset
|
809 s++; |
83a99f08d1e8
patch 8.2.3925: diff mode confused by NUL bytes
Bram Moolenaar <Bram@vim.org>
parents:
26786
diff
changeset
|
810 } |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
811 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
812 ptr[len++] = NL; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
813 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
814 return OK; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
815 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
816 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
817 /* |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
818 * Write buffer "buf" to file or memory buffer. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
819 * Return FAIL for failure. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
820 */ |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
821 static int |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
822 diff_write(buf_T *buf, diffin_T *din) |
7 | 823 { |
824 int r; | |
825 char_u *save_ff; | |
22699
e82579016863
patch 8.2.1898: command modifier parsing always uses global cmdmod
Bram Moolenaar <Bram@vim.org>
parents:
20772
diff
changeset
|
826 int save_cmod_flags; |
7 | 827 |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
828 if (din->din_fname == NULL) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
829 return diff_write_buffer(buf, din); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
830 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
831 // Always use 'fileformat' set to "unix". |
7 | 832 save_ff = buf->b_p_ff; |
833 buf->b_p_ff = vim_strsave((char_u *)FF_UNIX); | |
22699
e82579016863
patch 8.2.1898: command modifier parsing always uses global cmdmod
Bram Moolenaar <Bram@vim.org>
parents:
20772
diff
changeset
|
834 save_cmod_flags = cmdmod.cmod_flags; |
18619
788d76db02ac
patch 8.1.2302: :lockmarks does not work for '[ and ']
Bram Moolenaar <Bram@vim.org>
parents:
18590
diff
changeset
|
835 // Writing the buffer is an implementation detail of performing the diff, |
788d76db02ac
patch 8.1.2302: :lockmarks does not work for '[ and ']
Bram Moolenaar <Bram@vim.org>
parents:
18590
diff
changeset
|
836 // so it shouldn't update the '[ and '] marks. |
22699
e82579016863
patch 8.2.1898: command modifier parsing always uses global cmdmod
Bram Moolenaar <Bram@vim.org>
parents:
20772
diff
changeset
|
837 cmdmod.cmod_flags |= CMOD_LOCKMARKS; |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
838 r = buf_write(buf, din->din_fname, NULL, |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
839 (linenr_T)1, buf->b_ml.ml_line_count, |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
840 NULL, FALSE, FALSE, FALSE, TRUE); |
22699
e82579016863
patch 8.2.1898: command modifier parsing always uses global cmdmod
Bram Moolenaar <Bram@vim.org>
parents:
20772
diff
changeset
|
841 cmdmod.cmod_flags = save_cmod_flags; |
7 | 842 free_string_option(buf->b_p_ff); |
843 buf->b_p_ff = save_ff; | |
844 return r; | |
845 } | |
846 | |
847 /* | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
848 * Update the diffs for all buffers involved. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
849 */ |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
850 static void |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
851 diff_try_update( |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
852 diffio_T *dio, |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
853 int idx_orig, |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
854 exarg_T *eap) // "eap" can be NULL |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
855 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
856 buf_T *buf; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
857 int idx_new; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
858 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
859 if (dio->dio_internal) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
860 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
861 ga_init2(&dio->dio_diff.dout_ga, sizeof(char *), 1000); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
862 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
863 else |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
864 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
865 // We need three temp file names. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
866 dio->dio_orig.din_fname = vim_tempname('o', TRUE); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
867 dio->dio_new.din_fname = vim_tempname('n', TRUE); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
868 dio->dio_diff.dout_fname = vim_tempname('d', TRUE); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
869 if (dio->dio_orig.din_fname == NULL |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
870 || dio->dio_new.din_fname == NULL |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
871 || dio->dio_diff.dout_fname == NULL) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
872 goto theend; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
873 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
874 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
875 // Check external diff is actually working. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
876 if (!dio->dio_internal && check_external_diff(dio) == FAIL) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
877 goto theend; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
878 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
879 // :diffupdate! |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
880 if (eap != NULL && eap->forceit) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
881 for (idx_new = idx_orig; idx_new < DB_COUNT; ++idx_new) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
882 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
883 buf = curtab->tp_diffbuf[idx_new]; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
884 if (buf_valid(buf)) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
885 buf_check_timestamp(buf, FALSE); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
886 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
887 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
888 // Write the first buffer to a tempfile or mmfile_t. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
889 buf = curtab->tp_diffbuf[idx_orig]; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
890 if (diff_write(buf, &dio->dio_orig) == FAIL) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
891 goto theend; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
892 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
893 // Make a difference between the first buffer and every other. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
894 for (idx_new = idx_orig + 1; idx_new < DB_COUNT; ++idx_new) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
895 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
896 buf = curtab->tp_diffbuf[idx_new]; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
897 if (buf == NULL || buf->b_ml.ml_mfp == NULL) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
898 continue; // skip buffer that isn't loaded |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
899 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
900 // Write the other buffer and diff with the first one. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
901 if (diff_write(buf, &dio->dio_new) == FAIL) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
902 continue; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
903 if (diff_file(dio) == FAIL) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
904 continue; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
905 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
906 // Read the diff output and add each entry to the diff list. |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
907 diff_read(idx_orig, idx_new, dio); |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
908 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
909 clear_diffin(&dio->dio_new); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
910 clear_diffout(&dio->dio_diff); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
911 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
912 clear_diffin(&dio->dio_orig); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
913 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
914 theend: |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
915 vim_free(dio->dio_orig.din_fname); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
916 vim_free(dio->dio_new.din_fname); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
917 vim_free(dio->dio_diff.dout_fname); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
918 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
919 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
920 /* |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
921 * Return TRUE if the options are set to use the internal diff library. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
922 * Note that if the internal diff failed for one of the buffers, the external |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
923 * diff will be used anyway. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
924 */ |
14764
f562b9fbd0d3
patch 8.1.0394: diffs are not always updated correctly
Christian Brabandt <cb@256bit.org>
parents:
14762
diff
changeset
|
925 int |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
926 diff_internal(void) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
927 { |
15971
ced614446eaa
patch 8.1.0991: cannot build with a mix of features
Bram Moolenaar <Bram@vim.org>
parents:
15900
diff
changeset
|
928 return (diff_flags & DIFF_INTERNAL) != 0 |
ced614446eaa
patch 8.1.0991: cannot build with a mix of features
Bram Moolenaar <Bram@vim.org>
parents:
15900
diff
changeset
|
929 #ifdef FEAT_EVAL |
ced614446eaa
patch 8.1.0991: cannot build with a mix of features
Bram Moolenaar <Bram@vim.org>
parents:
15900
diff
changeset
|
930 && *p_dex == NUL |
ced614446eaa
patch 8.1.0991: cannot build with a mix of features
Bram Moolenaar <Bram@vim.org>
parents:
15900
diff
changeset
|
931 #endif |
ced614446eaa
patch 8.1.0991: cannot build with a mix of features
Bram Moolenaar <Bram@vim.org>
parents:
15900
diff
changeset
|
932 ; |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
933 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
934 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
935 /* |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
936 * Return TRUE if the internal diff failed for one of the diff buffers. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
937 */ |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
938 static int |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
939 diff_internal_failed(void) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
940 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
941 int idx; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
942 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
943 // Only need to do something when there is another buffer. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
944 for (idx = 0; idx < DB_COUNT; ++idx) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
945 if (curtab->tp_diffbuf[idx] != NULL |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
946 && curtab->tp_diffbuf[idx]->b_diff_failed) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
947 return TRUE; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
948 return FALSE; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
949 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
950 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
951 /* |
7 | 952 * Completely update the diffs for the buffers involved. |
14764
f562b9fbd0d3
patch 8.1.0394: diffs are not always updated correctly
Christian Brabandt <cb@256bit.org>
parents:
14762
diff
changeset
|
953 * When using the external "diff" command the buffers are written to a file, |
f562b9fbd0d3
patch 8.1.0394: diffs are not always updated correctly
Christian Brabandt <cb@256bit.org>
parents:
14762
diff
changeset
|
954 * also for unmodified buffers (the file could have been produced by |
f562b9fbd0d3
patch 8.1.0394: diffs are not always updated correctly
Christian Brabandt <cb@256bit.org>
parents:
14762
diff
changeset
|
955 * autocommands, e.g. the netrw plugin). |
7 | 956 */ |
957 void | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
958 ex_diffupdate(exarg_T *eap) // "eap" can be NULL |
7 | 959 { |
960 int idx_orig; | |
961 int idx_new; | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
962 diffio_T diffio; |
14780
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
963 int had_diffs = curtab->tp_first_diff != NULL; |
7 | 964 |
14776
09c1f241e2f7
patch 8.1.0400: using freed memory with :diffget
Christian Brabandt <cb@256bit.org>
parents:
14770
diff
changeset
|
965 if (diff_busy) |
09c1f241e2f7
patch 8.1.0400: using freed memory with :diffget
Christian Brabandt <cb@256bit.org>
parents:
14770
diff
changeset
|
966 { |
09c1f241e2f7
patch 8.1.0400: using freed memory with :diffget
Christian Brabandt <cb@256bit.org>
parents:
14770
diff
changeset
|
967 diff_need_update = TRUE; |
09c1f241e2f7
patch 8.1.0400: using freed memory with :diffget
Christian Brabandt <cb@256bit.org>
parents:
14770
diff
changeset
|
968 return; |
09c1f241e2f7
patch 8.1.0400: using freed memory with :diffget
Christian Brabandt <cb@256bit.org>
parents:
14770
diff
changeset
|
969 } |
09c1f241e2f7
patch 8.1.0400: using freed memory with :diffget
Christian Brabandt <cb@256bit.org>
parents:
14770
diff
changeset
|
970 |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
971 // Delete all diffblocks. |
672 | 972 diff_clear(curtab); |
973 curtab->tp_diff_invalid = FALSE; | |
7 | 974 |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
975 // Use the first buffer as the original text. |
7 | 976 for (idx_orig = 0; idx_orig < DB_COUNT; ++idx_orig) |
672 | 977 if (curtab->tp_diffbuf[idx_orig] != NULL) |
7 | 978 break; |
979 if (idx_orig == DB_COUNT) | |
14780
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
980 goto theend; |
7 | 981 |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
982 // Only need to do something when there is another buffer. |
7 | 983 for (idx_new = idx_orig + 1; idx_new < DB_COUNT; ++idx_new) |
672 | 984 if (curtab->tp_diffbuf[idx_new] != NULL) |
7 | 985 break; |
986 if (idx_new == DB_COUNT) | |
14780
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
987 goto theend; |
7 | 988 |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
989 // Only use the internal method if it did not fail for one of the buffers. |
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19888
diff
changeset
|
990 CLEAR_FIELD(diffio); |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
991 diffio.dio_internal = diff_internal() && !diff_internal_failed(); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
992 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
993 diff_try_update(&diffio, idx_orig, eap); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
994 if (diffio.dio_internal && diff_internal_failed()) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
995 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
996 // Internal diff failed, use external diff instead. |
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19888
diff
changeset
|
997 CLEAR_FIELD(diffio); |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
998 diff_try_update(&diffio, idx_orig, eap); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
999 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1000 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1001 // force updating cursor position on screen |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1002 curwin->w_valid_cursor.lnum = 0; |
7 | 1003 |
14780
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
1004 theend: |
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
1005 // A redraw is needed if there were diffs and they were cleared, or there |
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
1006 // are diffs now, which means they got updated. |
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
1007 if (had_diffs || curtab->tp_first_diff != NULL) |
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
1008 { |
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
1009 diff_redraw(TRUE); |
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
1010 apply_autocmds(EVENT_DIFFUPDATED, NULL, NULL, FALSE, curbuf); |
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
1011 } |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1012 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1013 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1014 /* |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1015 * Do a quick test if "diff" really works. Otherwise it looks like there |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1016 * are no differences. Can't use the return value, it's non-zero when |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1017 * there are differences. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1018 */ |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1019 static int |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1020 check_external_diff(diffio_T *diffio) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1021 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1022 FILE *fd; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1023 int ok; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1024 int io_error = FALSE; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1025 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1026 // May try twice, first with "-a" and then without. |
7 | 1027 for (;;) |
1028 { | |
1029 ok = FALSE; | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1030 fd = mch_fopen((char *)diffio->dio_orig.din_fname, "w"); |
1757 | 1031 if (fd == NULL) |
1032 io_error = TRUE; | |
1033 else | |
7 | 1034 { |
1757 | 1035 if (fwrite("line1\n", (size_t)6, (size_t)1, fd) != 1) |
1036 io_error = TRUE; | |
7 | 1037 fclose(fd); |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1038 fd = mch_fopen((char *)diffio->dio_new.din_fname, "w"); |
1757 | 1039 if (fd == NULL) |
1040 io_error = TRUE; | |
1041 else | |
7 | 1042 { |
1757 | 1043 if (fwrite("line2\n", (size_t)6, (size_t)1, fd) != 1) |
1044 io_error = TRUE; | |
7 | 1045 fclose(fd); |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1046 fd = NULL; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1047 if (diff_file(diffio) == OK) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1048 fd = mch_fopen((char *)diffio->dio_diff.dout_fname, "r"); |
1757 | 1049 if (fd == NULL) |
1050 io_error = TRUE; | |
1051 else | |
7 | 1052 { |
1053 char_u linebuf[LBUFLEN]; | |
1054 | |
1055 for (;;) | |
1056 { | |
24683
05c199ea8295
patch 8.2.2880: unified diff fails if actually used
Bram Moolenaar <Bram@vim.org>
parents:
23895
diff
changeset
|
1057 // For normal diff there must be a line that contains |
05c199ea8295
patch 8.2.2880: unified diff fails if actually used
Bram Moolenaar <Bram@vim.org>
parents:
23895
diff
changeset
|
1058 // "1c1". For unified diff "@@ -1 +1 @@". |
15840
734b1928a5aa
patch 8.1.0927: USE_CR is never defined
Bram Moolenaar <Bram@vim.org>
parents:
15595
diff
changeset
|
1059 if (vim_fgets(linebuf, LBUFLEN, fd)) |
7 | 1060 break; |
24683
05c199ea8295
patch 8.2.2880: unified diff fails if actually used
Bram Moolenaar <Bram@vim.org>
parents:
23895
diff
changeset
|
1061 if (STRNCMP(linebuf, "1c1", 3) == 0 |
05c199ea8295
patch 8.2.2880: unified diff fails if actually used
Bram Moolenaar <Bram@vim.org>
parents:
23895
diff
changeset
|
1062 || STRNCMP(linebuf, "@@ -1 +1 @@", 11) == 0) |
7 | 1063 ok = TRUE; |
1064 } | |
1065 fclose(fd); | |
1066 } | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1067 mch_remove(diffio->dio_diff.dout_fname); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1068 mch_remove(diffio->dio_new.din_fname); |
7 | 1069 } |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1070 mch_remove(diffio->dio_orig.din_fname); |
7 | 1071 } |
1072 | |
1073 #ifdef FEAT_EVAL | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1074 // When using 'diffexpr' break here. |
7 | 1075 if (*p_dex != NUL) |
1076 break; | |
1077 #endif | |
1078 | |
8212
05b88224cea1
commit https://github.com/vim/vim/commit/48e330aff911be1c798c88a973af6437a8141fce
Christian Brabandt <cb@256bit.org>
parents:
7817
diff
changeset
|
1079 #if defined(MSWIN) |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1080 // If the "-a" argument works, also check if "--binary" works. |
7 | 1081 if (ok && diff_a_works == MAYBE && diff_bin_works == MAYBE) |
1082 { | |
1083 diff_a_works = TRUE; | |
1084 diff_bin_works = TRUE; | |
1085 continue; | |
1086 } | |
1087 if (!ok && diff_a_works == TRUE && diff_bin_works == TRUE) | |
1088 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1089 // Tried --binary, but it failed. "-a" works though. |
7 | 1090 diff_bin_works = FALSE; |
1091 ok = TRUE; | |
1092 } | |
1093 #endif | |
1094 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1095 // If we checked if "-a" works already, break here. |
7 | 1096 if (diff_a_works != MAYBE) |
1097 break; | |
1098 diff_a_works = ok; | |
1099 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1100 // If "-a" works break here, otherwise retry without "-a". |
7 | 1101 if (ok) |
1102 break; | |
1103 } | |
1104 if (!ok) | |
1105 { | |
1757 | 1106 if (io_error) |
26962
85866e069c24
patch 8.2.4010: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26958
diff
changeset
|
1107 emsg(_(e_cannot_read_or_write_temp_files)); |
26602
fac6673086df
patch 8.2.3830: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26044
diff
changeset
|
1108 emsg(_(e_cannot_create_diffs)); |
7 | 1109 diff_a_works = MAYBE; |
8212
05b88224cea1
commit https://github.com/vim/vim/commit/48e330aff911be1c798c88a973af6437a8141fce
Christian Brabandt <cb@256bit.org>
parents:
7817
diff
changeset
|
1110 #if defined(MSWIN) |
7 | 1111 diff_bin_works = MAYBE; |
1112 #endif | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1113 return FAIL; |
7 | 1114 } |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1115 return OK; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1116 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1117 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1118 /* |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1119 * Invoke the xdiff function. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1120 */ |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1121 static int |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1122 diff_file_internal(diffio_T *diffio) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1123 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1124 xpparam_t param; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1125 xdemitconf_t emit_cfg; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1126 xdemitcb_t emit_cb; |
7 | 1127 |
20007
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19888
diff
changeset
|
1128 CLEAR_FIELD(param); |
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19888
diff
changeset
|
1129 CLEAR_FIELD(emit_cfg); |
aadd1cae2ff5
patch 8.2.0559: clearing a struct is verbose
Bram Moolenaar <Bram@vim.org>
parents:
19888
diff
changeset
|
1130 CLEAR_FIELD(emit_cb); |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1131 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1132 param.flags = diff_algorithm; |
3524 | 1133 |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1134 if (diff_flags & DIFF_IWHITE) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1135 param.flags |= XDF_IGNORE_WHITESPACE_CHANGE; |
14762
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
1136 if (diff_flags & DIFF_IWHITEALL) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
1137 param.flags |= XDF_IGNORE_WHITESPACE; |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
1138 if (diff_flags & DIFF_IWHITEEOL) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
1139 param.flags |= XDF_IGNORE_WHITESPACE_AT_EOL; |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
1140 if (diff_flags & DIFF_IBLANK) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
1141 param.flags |= XDF_IGNORE_BLANK_LINES; |
7 | 1142 |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1143 emit_cfg.ctxlen = 0; // don't need any diff_context here |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1144 emit_cb.priv = &diffio->dio_diff; |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1145 emit_cfg.hunk_func = xdiff_out; |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1146 if (xdl_diff(&diffio->dio_orig.din_mmfile, |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1147 &diffio->dio_new.din_mmfile, |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1148 ¶m, &emit_cfg, &emit_cb) < 0) |
7 | 1149 { |
26966
ac75c145f0a9
patch 8.2.4012: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26962
diff
changeset
|
1150 emsg(_(e_problem_creating_internal_diff)); |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1151 return FAIL; |
7 | 1152 } |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1153 return OK; |
7 | 1154 } |
1155 | |
1156 /* | |
1157 * Make a diff between files "tmp_orig" and "tmp_new", results in "tmp_diff". | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1158 * return OK or FAIL; |
7 | 1159 */ |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1160 static int |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1161 diff_file(diffio_T *dio) |
7 | 1162 { |
1163 char_u *cmd; | |
1872 | 1164 size_t len; |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1165 char_u *tmp_orig = dio->dio_orig.din_fname; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1166 char_u *tmp_new = dio->dio_new.din_fname; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1167 char_u *tmp_diff = dio->dio_diff.dout_fname; |
7 | 1168 |
1169 #ifdef FEAT_EVAL | |
1170 if (*p_dex != NUL) | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1171 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1172 // Use 'diffexpr' to generate the diff file. |
7 | 1173 eval_diff(tmp_orig, tmp_new, tmp_diff); |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1174 return OK; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1175 } |
7 | 1176 else |
1177 #endif | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1178 // Use xdiff for generating the diff. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1179 if (dio->dio_internal) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1180 return diff_file_internal(dio); |
31531
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1181 |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1182 len = STRLEN(tmp_orig) + STRLEN(tmp_new) |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1183 + STRLEN(tmp_diff) + STRLEN(p_srr) + 27; |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1184 cmd = alloc(len); |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1185 if (cmd == NULL) |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1186 return FAIL; |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1187 |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1188 // We don't want $DIFF_OPTIONS to get in the way. |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1189 if (getenv("DIFF_OPTIONS")) |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1190 vim_setenv((char_u *)"DIFF_OPTIONS", (char_u *)""); |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1191 |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1192 // Build the diff command and execute it. Always use -a, binary |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1193 // differences are of no use. Ignore errors, diff returns |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1194 // non-zero when differences have been found. |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1195 vim_snprintf((char *)cmd, len, "diff %s%s%s%s%s%s%s%s %s", |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1196 diff_a_works == FALSE ? "" : "-a ", |
8212
05b88224cea1
commit https://github.com/vim/vim/commit/48e330aff911be1c798c88a973af6437a8141fce
Christian Brabandt <cb@256bit.org>
parents:
7817
diff
changeset
|
1197 #if defined(MSWIN) |
31531
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1198 diff_bin_works == TRUE ? "--binary " : "", |
7 | 1199 #else |
31531
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1200 "", |
7 | 1201 #endif |
31531
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1202 (diff_flags & DIFF_IWHITE) ? "-b " : "", |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1203 (diff_flags & DIFF_IWHITEALL) ? "-w " : "", |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1204 (diff_flags & DIFF_IWHITEEOL) ? "-Z " : "", |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1205 (diff_flags & DIFF_IBLANK) ? "-B " : "", |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1206 (diff_flags & DIFF_ICASE) ? "-i " : "", |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1207 tmp_orig, tmp_new); |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1208 append_redir(cmd, (int)len, p_srr, tmp_diff); |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1209 block_autocmds(); // avoid ShellCmdPost stuff |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1210 (void)call_shell(cmd, SHELL_FILTER|SHELL_SILENT|SHELL_DOOUT); |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1211 unblock_autocmds(); |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1212 vim_free(cmd); |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1213 return OK; |
7 | 1214 } |
1215 | |
1216 /* | |
1217 * Create a new version of a file from the current buffer and a diff file. | |
1218 * The buffer is written to a file, also for unmodified buffers (the file | |
1219 * could have been produced by autocommands, e.g. the netrw plugin). | |
1220 */ | |
1221 void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
1222 ex_diffpatch(exarg_T *eap) |
7 | 1223 { |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1224 char_u *tmp_orig; // name of original temp file |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1225 char_u *tmp_new; // name of patched temp file |
7 | 1226 char_u *buf = NULL; |
1872 | 1227 size_t buflen; |
7 | 1228 win_T *old_curwin = curwin; |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1229 char_u *newname = NULL; // name of patched file buffer |
7 | 1230 #ifdef UNIX |
1231 char_u dirbuf[MAXPATHL]; | |
1232 char_u *fullname = NULL; | |
1233 #endif | |
1234 #ifdef FEAT_BROWSE | |
1235 char_u *browseFile = NULL; | |
22699
e82579016863
patch 8.2.1898: command modifier parsing always uses global cmdmod
Bram Moolenaar <Bram@vim.org>
parents:
20772
diff
changeset
|
1236 int save_cmod_flags = cmdmod.cmod_flags; |
7 | 1237 #endif |
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
8368
diff
changeset
|
1238 stat_T st; |
11113
081ed9efb5c0
patch 8.0.0444: diffpatch fails when the file name has a quote
Christian Brabandt <cb@256bit.org>
parents:
11109
diff
changeset
|
1239 char_u *esc_name = NULL; |
7 | 1240 |
1241 #ifdef FEAT_BROWSE | |
22699
e82579016863
patch 8.2.1898: command modifier parsing always uses global cmdmod
Bram Moolenaar <Bram@vim.org>
parents:
20772
diff
changeset
|
1242 if (cmdmod.cmod_flags & CMOD_BROWSE) |
7 | 1243 { |
28 | 1244 browseFile = do_browse(0, (char_u *)_("Patch file"), |
13802
378f9f8e6d8f
patch 8.0.1773: dialog messages are not translated
Christian Brabandt <cb@256bit.org>
parents:
13384
diff
changeset
|
1245 eap->arg, NULL, NULL, |
378f9f8e6d8f
patch 8.0.1773: dialog messages are not translated
Christian Brabandt <cb@256bit.org>
parents:
13384
diff
changeset
|
1246 (char_u *)_(BROWSE_FILTER_ALL_FILES), NULL); |
7 | 1247 if (browseFile == NULL) |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1248 return; // operation cancelled |
7 | 1249 eap->arg = browseFile; |
22699
e82579016863
patch 8.2.1898: command modifier parsing always uses global cmdmod
Bram Moolenaar <Bram@vim.org>
parents:
20772
diff
changeset
|
1250 cmdmod.cmod_flags &= ~CMOD_BROWSE; // don't let do_ecmd() browse again |
7 | 1251 } |
1252 #endif | |
1253 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1254 // We need two temp file names. |
6721 | 1255 tmp_orig = vim_tempname('o', FALSE); |
1256 tmp_new = vim_tempname('n', FALSE); | |
7 | 1257 if (tmp_orig == NULL || tmp_new == NULL) |
1258 goto theend; | |
1259 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1260 // Write the current buffer to "tmp_orig". |
7 | 1261 if (buf_write(curbuf, tmp_orig, NULL, |
1262 (linenr_T)1, curbuf->b_ml.ml_line_count, | |
1263 NULL, FALSE, FALSE, FALSE, TRUE) == FAIL) | |
1264 goto theend; | |
1265 | |
1266 #ifdef UNIX | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1267 // Get the absolute path of the patchfile, changing directory below. |
7 | 1268 fullname = FullName_save(eap->arg, FALSE); |
1269 #endif | |
11113
081ed9efb5c0
patch 8.0.0444: diffpatch fails when the file name has a quote
Christian Brabandt <cb@256bit.org>
parents:
11109
diff
changeset
|
1270 esc_name = vim_strsave_shellescape( |
7 | 1271 # ifdef UNIX |
11113
081ed9efb5c0
patch 8.0.0444: diffpatch fails when the file name has a quote
Christian Brabandt <cb@256bit.org>
parents:
11109
diff
changeset
|
1272 fullname != NULL ? fullname : |
7 | 1273 # endif |
11113
081ed9efb5c0
patch 8.0.0444: diffpatch fails when the file name has a quote
Christian Brabandt <cb@256bit.org>
parents:
11109
diff
changeset
|
1274 eap->arg, TRUE, TRUE); |
081ed9efb5c0
patch 8.0.0444: diffpatch fails when the file name has a quote
Christian Brabandt <cb@256bit.org>
parents:
11109
diff
changeset
|
1275 if (esc_name == NULL) |
081ed9efb5c0
patch 8.0.0444: diffpatch fails when the file name has a quote
Christian Brabandt <cb@256bit.org>
parents:
11109
diff
changeset
|
1276 goto theend; |
081ed9efb5c0
patch 8.0.0444: diffpatch fails when the file name has a quote
Christian Brabandt <cb@256bit.org>
parents:
11109
diff
changeset
|
1277 buflen = STRLEN(tmp_orig) + STRLEN(esc_name) + STRLEN(tmp_new) + 16; |
16764
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
15971
diff
changeset
|
1278 buf = alloc(buflen); |
7 | 1279 if (buf == NULL) |
1280 goto theend; | |
1281 | |
1282 #ifdef UNIX | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1283 // Temporarily chdir to /tmp, to avoid patching files in the current |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1284 // directory when the patch file contains more than one patch. When we |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1285 // have our own temp dir use that instead, it will be cleaned up when we |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1286 // exit (any .rej files created). Don't change directory if we can't |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1287 // return to the current. |
7 | 1288 if (mch_dirname(dirbuf, MAXPATHL) != OK || mch_chdir((char *)dirbuf) != 0) |
1289 dirbuf[0] = NUL; | |
1290 else | |
1291 { | |
1292 # ifdef TEMPDIRNAMES | |
1293 if (vim_tempdir != NULL) | |
14730
193471015e1a
patch 8.1.0377: xdiff doesn't use the Vim memory allocation functions
Christian Brabandt <cb@256bit.org>
parents:
14726
diff
changeset
|
1294 vim_ignored = mch_chdir((char *)vim_tempdir); |
7 | 1295 else |
1296 # endif | |
14730
193471015e1a
patch 8.1.0377: xdiff doesn't use the Vim memory allocation functions
Christian Brabandt <cb@256bit.org>
parents:
14726
diff
changeset
|
1297 vim_ignored = mch_chdir("/tmp"); |
7 | 1298 shorten_fnames(TRUE); |
1299 } | |
1300 #endif | |
1301 | |
1302 #ifdef FEAT_EVAL | |
1303 if (*p_pex != NUL) | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1304 // Use 'patchexpr' to generate the new file. |
7 | 1305 eval_patch(tmp_orig, |
1306 # ifdef UNIX | |
1307 fullname != NULL ? fullname : | |
1308 # endif | |
1309 eap->arg, tmp_new); | |
1310 else | |
1311 #endif | |
1312 { | |
32218
9c6bc59b6d80
patch 9.0.1440: "rvim" can execute a shell through :diffpatch
Bram Moolenaar <Bram@vim.org>
parents:
32120
diff
changeset
|
1313 if (check_restricted()) |
9c6bc59b6d80
patch 9.0.1440: "rvim" can execute a shell through :diffpatch
Bram Moolenaar <Bram@vim.org>
parents:
32120
diff
changeset
|
1314 goto theend; |
9c6bc59b6d80
patch 9.0.1440: "rvim" can execute a shell through :diffpatch
Bram Moolenaar <Bram@vim.org>
parents:
32120
diff
changeset
|
1315 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1316 // Build the patch command and execute it. Ignore errors. Switch to |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1317 // cooked mode to allow the user to respond to prompts. |
11113
081ed9efb5c0
patch 8.0.0444: diffpatch fails when the file name has a quote
Christian Brabandt <cb@256bit.org>
parents:
11109
diff
changeset
|
1318 vim_snprintf((char *)buf, buflen, "patch -o %s %s < %s", |
081ed9efb5c0
patch 8.0.0444: diffpatch fails when the file name has a quote
Christian Brabandt <cb@256bit.org>
parents:
11109
diff
changeset
|
1319 tmp_new, tmp_orig, esc_name); |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1320 block_autocmds(); // Avoid ShellCmdPost stuff |
7 | 1321 (void)call_shell(buf, SHELL_FILTER | SHELL_COOKED); |
1410 | 1322 unblock_autocmds(); |
7 | 1323 } |
1324 | |
1325 #ifdef UNIX | |
1326 if (dirbuf[0] != NUL) | |
1327 { | |
1328 if (mch_chdir((char *)dirbuf) != 0) | |
26877
06a137af96f8
patch 8.2.3967: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26829
diff
changeset
|
1329 emsg(_(e_cannot_go_back_to_previous_directory)); |
7 | 1330 shorten_fnames(TRUE); |
1331 } | |
1332 #endif | |
1333 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1334 // patch probably has written over the screen |
29732
89e1d67814a9
patch 9.0.0206: redraw flags are not named specifically
Bram Moolenaar <Bram@vim.org>
parents:
29566
diff
changeset
|
1335 redraw_later(UPD_CLEAR); |
7 | 1336 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1337 // Delete any .orig or .rej file created. |
7 | 1338 STRCPY(buf, tmp_new); |
1339 STRCAT(buf, ".orig"); | |
1340 mch_remove(buf); | |
1341 STRCPY(buf, tmp_new); | |
1342 STRCAT(buf, ".rej"); | |
1343 mch_remove(buf); | |
1344 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1345 // Only continue if the output file was created. |
1942 | 1346 if (mch_stat((char *)tmp_new, &st) < 0 || st.st_size == 0) |
26962
85866e069c24
patch 8.2.4010: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26958
diff
changeset
|
1347 emsg(_(e_cannot_read_patch_output)); |
1942 | 1348 else |
7 | 1349 { |
1942 | 1350 if (curbuf->b_fname != NULL) |
1351 { | |
1352 newname = vim_strnsave(curbuf->b_fname, | |
20751
d9a2e5dcfd9f
patch 8.2.0928: many type casts are used for vim_strnsave()
Bram Moolenaar <Bram@vim.org>
parents:
20599
diff
changeset
|
1353 STRLEN(curbuf->b_fname) + 4); |
1942 | 1354 if (newname != NULL) |
1355 STRCAT(newname, ".new"); | |
1356 } | |
7 | 1357 |
1358 #ifdef FEAT_GUI | |
1942 | 1359 need_mouse_correct = TRUE; |
7 | 1360 #endif |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1361 // don't use a new tab page, each tab page has its own diffs |
22699
e82579016863
patch 8.2.1898: command modifier parsing always uses global cmdmod
Bram Moolenaar <Bram@vim.org>
parents:
20772
diff
changeset
|
1362 cmdmod.cmod_tab = 0; |
682 | 1363 |
1942 | 1364 if (win_split(0, (diff_flags & DIFF_VERTICAL) ? WSP_VERT : 0) != FAIL) |
1365 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1366 // Pretend it was a ":split fname" command |
1942 | 1367 eap->cmdidx = CMD_split; |
1368 eap->arg = tmp_new; | |
1369 do_exedit(eap, old_curwin); | |
7 | 1370 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1371 // check that split worked and editing tmp_new |
1942 | 1372 if (curwin != old_curwin && win_valid(old_curwin)) |
1373 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1374 // Set 'diff', 'scrollbind' on and 'wrap' off. |
1942 | 1375 diff_win_options(curwin, TRUE); |
1376 diff_win_options(old_curwin, TRUE); | |
7 | 1377 |
1942 | 1378 if (newname != NULL) |
1379 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1380 // do a ":file filename.new" on the patched buffer |
1942 | 1381 eap->arg = newname; |
1382 ex_file(eap); | |
7 | 1383 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1384 // Do filetype detection with the new name. |
1942 | 1385 if (au_has_group((char_u *)"filetypedetect")) |
32218
9c6bc59b6d80
patch 9.0.1440: "rvim" can execute a shell through :diffpatch
Bram Moolenaar <Bram@vim.org>
parents:
32120
diff
changeset
|
1386 do_cmdline_cmd( |
9c6bc59b6d80
patch 9.0.1440: "rvim" can execute a shell through :diffpatch
Bram Moolenaar <Bram@vim.org>
parents:
32120
diff
changeset
|
1387 (char_u *)":doau filetypedetect BufRead"); |
1942 | 1388 } |
7 | 1389 } |
1390 } | |
1391 } | |
1392 | |
1393 theend: | |
1394 if (tmp_orig != NULL) | |
1395 mch_remove(tmp_orig); | |
1396 vim_free(tmp_orig); | |
1397 if (tmp_new != NULL) | |
1398 mch_remove(tmp_new); | |
1399 vim_free(tmp_new); | |
1400 vim_free(newname); | |
1401 vim_free(buf); | |
1402 #ifdef UNIX | |
1403 vim_free(fullname); | |
1404 #endif | |
11113
081ed9efb5c0
patch 8.0.0444: diffpatch fails when the file name has a quote
Christian Brabandt <cb@256bit.org>
parents:
11109
diff
changeset
|
1405 vim_free(esc_name); |
7 | 1406 #ifdef FEAT_BROWSE |
1407 vim_free(browseFile); | |
22699
e82579016863
patch 8.2.1898: command modifier parsing always uses global cmdmod
Bram Moolenaar <Bram@vim.org>
parents:
20772
diff
changeset
|
1408 cmdmod.cmod_flags = save_cmod_flags; |
7 | 1409 #endif |
1410 } | |
1411 | |
1412 /* | |
1413 * Split the window and edit another file, setting options to show the diffs. | |
1414 */ | |
1415 void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
1416 ex_diffsplit(exarg_T *eap) |
7 | 1417 { |
1418 win_T *old_curwin = curwin; | |
9487
69ed2c9d34a6
commit https://github.com/vim/vim/commit/7c0a2f367f2507669560b1a66423155c70d2e75b
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
1419 bufref_T old_curbuf; |
7 | 1420 |
9487
69ed2c9d34a6
commit https://github.com/vim/vim/commit/7c0a2f367f2507669560b1a66423155c70d2e75b
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
1421 set_bufref(&old_curbuf, curbuf); |
7 | 1422 #ifdef FEAT_GUI |
1423 need_mouse_correct = TRUE; | |
1424 #endif | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1425 // Need to compute w_fraction when no redraw happened yet. |
10013
942d40a92be6
commit https://github.com/vim/vim/commit/46328f9a1cc8047d1e05095bc9f531038c5a4028
Christian Brabandt <cb@256bit.org>
parents:
10005
diff
changeset
|
1426 validate_cursor(); |
942d40a92be6
commit https://github.com/vim/vim/commit/46328f9a1cc8047d1e05095bc9f531038c5a4028
Christian Brabandt <cb@256bit.org>
parents:
10005
diff
changeset
|
1427 set_fraction(curwin); |
942d40a92be6
commit https://github.com/vim/vim/commit/46328f9a1cc8047d1e05095bc9f531038c5a4028
Christian Brabandt <cb@256bit.org>
parents:
10005
diff
changeset
|
1428 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1429 // don't use a new tab page, each tab page has its own diffs |
22699
e82579016863
patch 8.2.1898: command modifier parsing always uses global cmdmod
Bram Moolenaar <Bram@vim.org>
parents:
20772
diff
changeset
|
1430 cmdmod.cmod_tab = 0; |
682 | 1431 |
31531
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1432 if (win_split(0, (diff_flags & DIFF_VERTICAL) ? WSP_VERT : 0) == FAIL) |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1433 return; |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1434 |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1435 // Pretend it was a ":split fname" command |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1436 eap->cmdidx = CMD_split; |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1437 curwin->w_p_diff = TRUE; |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1438 do_exedit(eap, old_curwin); |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1439 |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1440 if (curwin == old_curwin) // split didn't work |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1441 return; |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1442 |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1443 // Set 'diff', 'scrollbind' on and 'wrap' off. |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1444 diff_win_options(curwin, TRUE); |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1445 if (win_valid(old_curwin)) |
7 | 1446 { |
31531
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1447 diff_win_options(old_curwin, TRUE); |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1448 |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1449 if (bufref_valid(&old_curbuf)) |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1450 // Move the cursor position to that of the old window. |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1451 curwin->w_cursor.lnum = diff_get_corresponding_line( |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1452 old_curbuf.br_buf, old_curwin->w_cursor.lnum); |
7 | 1453 } |
31531
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1454 // Now that lines are folded scroll to show the cursor at the same |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1455 // relative position. |
6e24001000ed
patch 9.0.1098: code uses too much indent
Bram Moolenaar <Bram@vim.org>
parents:
31263
diff
changeset
|
1456 scroll_to_fraction(curwin, curwin->w_height); |
7 | 1457 } |
1458 | |
1459 /* | |
4352 | 1460 * Set options to show diffs for the current window. |
7 | 1461 */ |
1462 void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
1463 ex_diffthis(exarg_T *eap UNUSED) |
7 | 1464 { |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1465 // Set 'diff', 'scrollbind' on and 'wrap' off. |
7 | 1466 diff_win_options(curwin, TRUE); |
1467 } | |
1468 | |
11707
1395a3b6978d
patch 8.0.0736: OptionSet not triggered when entering diff mode
Christian Brabandt <cb@256bit.org>
parents:
11430
diff
changeset
|
1469 static void |
1395a3b6978d
patch 8.0.0736: OptionSet not triggered when entering diff mode
Christian Brabandt <cb@256bit.org>
parents:
11430
diff
changeset
|
1470 set_diff_option(win_T *wp, int value) |
1395a3b6978d
patch 8.0.0736: OptionSet not triggered when entering diff mode
Christian Brabandt <cb@256bit.org>
parents:
11430
diff
changeset
|
1471 { |
1395a3b6978d
patch 8.0.0736: OptionSet not triggered when entering diff mode
Christian Brabandt <cb@256bit.org>
parents:
11430
diff
changeset
|
1472 win_T *old_curwin = curwin; |
1395a3b6978d
patch 8.0.0736: OptionSet not triggered when entering diff mode
Christian Brabandt <cb@256bit.org>
parents:
11430
diff
changeset
|
1473 |
1395a3b6978d
patch 8.0.0736: OptionSet not triggered when entering diff mode
Christian Brabandt <cb@256bit.org>
parents:
11430
diff
changeset
|
1474 curwin = wp; |
1395a3b6978d
patch 8.0.0736: OptionSet not triggered when entering diff mode
Christian Brabandt <cb@256bit.org>
parents:
11430
diff
changeset
|
1475 curbuf = curwin->w_buffer; |
1395a3b6978d
patch 8.0.0736: OptionSet not triggered when entering diff mode
Christian Brabandt <cb@256bit.org>
parents:
11430
diff
changeset
|
1476 ++curbuf_lock; |
28457
4dcccb2673fe
patch 8.2.4753: error from setting an option is silently ignored
Bram Moolenaar <Bram@vim.org>
parents:
28197
diff
changeset
|
1477 set_option_value_give_err((char_u *)"diff", (long)value, NULL, OPT_LOCAL); |
11707
1395a3b6978d
patch 8.0.0736: OptionSet not triggered when entering diff mode
Christian Brabandt <cb@256bit.org>
parents:
11430
diff
changeset
|
1478 --curbuf_lock; |
1395a3b6978d
patch 8.0.0736: OptionSet not triggered when entering diff mode
Christian Brabandt <cb@256bit.org>
parents:
11430
diff
changeset
|
1479 curwin = old_curwin; |
1395a3b6978d
patch 8.0.0736: OptionSet not triggered when entering diff mode
Christian Brabandt <cb@256bit.org>
parents:
11430
diff
changeset
|
1480 curbuf = curwin->w_buffer; |
1395a3b6978d
patch 8.0.0736: OptionSet not triggered when entering diff mode
Christian Brabandt <cb@256bit.org>
parents:
11430
diff
changeset
|
1481 } |
1395a3b6978d
patch 8.0.0736: OptionSet not triggered when entering diff mode
Christian Brabandt <cb@256bit.org>
parents:
11430
diff
changeset
|
1482 |
7 | 1483 /* |
1484 * Set options in window "wp" for diff mode. | |
1485 */ | |
1486 void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
1487 diff_win_options( |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
1488 win_T *wp, |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1489 int addbuf) // Add buffer to diff. |
7 | 1490 { |
2086
c11845a465ae
updated for version 7.2.370
Bram Moolenaar <bram@zimbu.org>
parents:
1942
diff
changeset
|
1491 # ifdef FEAT_FOLDING |
c11845a465ae
updated for version 7.2.370
Bram Moolenaar <bram@zimbu.org>
parents:
1942
diff
changeset
|
1492 win_T *old_curwin = curwin; |
c11845a465ae
updated for version 7.2.370
Bram Moolenaar <bram@zimbu.org>
parents:
1942
diff
changeset
|
1493 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1494 // close the manually opened folds |
2086
c11845a465ae
updated for version 7.2.370
Bram Moolenaar <bram@zimbu.org>
parents:
1942
diff
changeset
|
1495 curwin = wp; |
c11845a465ae
updated for version 7.2.370
Bram Moolenaar <bram@zimbu.org>
parents:
1942
diff
changeset
|
1496 newFoldLevel(); |
c11845a465ae
updated for version 7.2.370
Bram Moolenaar <bram@zimbu.org>
parents:
1942
diff
changeset
|
1497 curwin = old_curwin; |
c11845a465ae
updated for version 7.2.370
Bram Moolenaar <bram@zimbu.org>
parents:
1942
diff
changeset
|
1498 # endif |
c11845a465ae
updated for version 7.2.370
Bram Moolenaar <bram@zimbu.org>
parents:
1942
diff
changeset
|
1499 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1500 // Use 'scrollbind' and 'cursorbind' when available |
6897 | 1501 if (!wp->w_p_diff) |
5102
11d0c6df1d7b
updated for version 7.3.1294
Bram Moolenaar <bram@vim.org>
parents:
4352
diff
changeset
|
1502 wp->w_p_scb_save = wp->w_p_scb; |
2583 | 1503 wp->w_p_scb = TRUE; |
6897 | 1504 if (!wp->w_p_diff) |
5102
11d0c6df1d7b
updated for version 7.3.1294
Bram Moolenaar <bram@vim.org>
parents:
4352
diff
changeset
|
1505 wp->w_p_crb_save = wp->w_p_crb; |
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
1506 wp->w_p_crb = TRUE; |
23895
e313b6ee2d9c
patch 8.2.2490: 'wrap' option is always reset when starting diff mode
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
1507 if (!(diff_flags & DIFF_FOLLOWWRAP)) |
e313b6ee2d9c
patch 8.2.2490: 'wrap' option is always reset when starting diff mode
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
1508 { |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1509 if (!wp->w_p_diff) |
23895
e313b6ee2d9c
patch 8.2.2490: 'wrap' option is always reset when starting diff mode
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
1510 wp->w_p_wrap_save = wp->w_p_wrap; |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1511 wp->w_p_wrap = FALSE; |
23895
e313b6ee2d9c
patch 8.2.2490: 'wrap' option is always reset when starting diff mode
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
1512 } |
7 | 1513 # ifdef FEAT_FOLDING |
6897 | 1514 if (!wp->w_p_diff) |
1515 { | |
1516 if (wp->w_p_diff_saved) | |
1517 free_string_option(wp->w_p_fdm_save); | |
5102
11d0c6df1d7b
updated for version 7.3.1294
Bram Moolenaar <bram@vim.org>
parents:
4352
diff
changeset
|
1518 wp->w_p_fdm_save = vim_strsave(wp->w_p_fdm); |
6897 | 1519 } |
16806
306766ed0f70
patch 8.1.1405: "highlight" option of popup windows not supported
Bram Moolenaar <Bram@vim.org>
parents:
16768
diff
changeset
|
1520 set_string_option_direct_in_win(wp, (char_u *)"fdm", -1, (char_u *)"diff", |
694 | 1521 OPT_LOCAL|OPT_FREE, 0); |
6897 | 1522 if (!wp->w_p_diff) |
5102
11d0c6df1d7b
updated for version 7.3.1294
Bram Moolenaar <bram@vim.org>
parents:
4352
diff
changeset
|
1523 { |
11d0c6df1d7b
updated for version 7.3.1294
Bram Moolenaar <bram@vim.org>
parents:
4352
diff
changeset
|
1524 wp->w_p_fdc_save = wp->w_p_fdc; |
11d0c6df1d7b
updated for version 7.3.1294
Bram Moolenaar <bram@vim.org>
parents:
4352
diff
changeset
|
1525 wp->w_p_fen_save = wp->w_p_fen; |
11d0c6df1d7b
updated for version 7.3.1294
Bram Moolenaar <bram@vim.org>
parents:
4352
diff
changeset
|
1526 wp->w_p_fdl_save = wp->w_p_fdl; |
11d0c6df1d7b
updated for version 7.3.1294
Bram Moolenaar <bram@vim.org>
parents:
4352
diff
changeset
|
1527 } |
2086
c11845a465ae
updated for version 7.2.370
Bram Moolenaar <bram@zimbu.org>
parents:
1942
diff
changeset
|
1528 wp->w_p_fdc = diff_foldcolumn; |
c11845a465ae
updated for version 7.2.370
Bram Moolenaar <bram@zimbu.org>
parents:
1942
diff
changeset
|
1529 wp->w_p_fen = TRUE; |
c11845a465ae
updated for version 7.2.370
Bram Moolenaar <bram@zimbu.org>
parents:
1942
diff
changeset
|
1530 wp->w_p_fdl = 0; |
c11845a465ae
updated for version 7.2.370
Bram Moolenaar <bram@zimbu.org>
parents:
1942
diff
changeset
|
1531 foldUpdateAll(wp); |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1532 // make sure topline is not halfway a fold |
2086
c11845a465ae
updated for version 7.2.370
Bram Moolenaar <bram@zimbu.org>
parents:
1942
diff
changeset
|
1533 changed_window_setting_win(wp); |
7 | 1534 # endif |
1535 if (vim_strchr(p_sbo, 'h') == NULL) | |
1536 do_cmdline_cmd((char_u *)"set sbo+=hor"); | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1537 // Save the current values, to be restored in ex_diffoff(). |
5102
11d0c6df1d7b
updated for version 7.3.1294
Bram Moolenaar <bram@vim.org>
parents:
4352
diff
changeset
|
1538 wp->w_p_diff_saved = TRUE; |
7 | 1539 |
11707
1395a3b6978d
patch 8.0.0736: OptionSet not triggered when entering diff mode
Christian Brabandt <cb@256bit.org>
parents:
11430
diff
changeset
|
1540 set_diff_option(wp, TRUE); |
6897 | 1541 |
7 | 1542 if (addbuf) |
1543 diff_buf_add(wp->w_buffer); | |
29732
89e1d67814a9
patch 9.0.0206: redraw flags are not named specifically
Bram Moolenaar <Bram@vim.org>
parents:
29566
diff
changeset
|
1544 redraw_win_later(wp, UPD_NOT_VALID); |
7 | 1545 } |
1546 | |
1547 /* | |
16 | 1548 * Set options not to show diffs. For the current window or all windows. |
671 | 1549 * Only in the current tab page. |
16 | 1550 */ |
1551 void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
1552 ex_diffoff(exarg_T *eap) |
16 | 1553 { |
1554 win_T *wp; | |
1555 int diffwin = FALSE; | |
1556 | |
9649
fd9727ae3c49
commit https://github.com/vim/vim/commit/2932359000b2f918d5fade79ea4d124d5943cd07
Christian Brabandt <cb@256bit.org>
parents:
9487
diff
changeset
|
1557 FOR_ALL_WINDOWS(wp) |
16 | 1558 { |
5358 | 1559 if (eap->forceit ? wp->w_p_diff : wp == curwin) |
16 | 1560 { |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1561 // Set 'diff' off. If option values were saved in |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1562 // diff_win_options(), restore the ones whose settings seem to have |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1563 // been left over from diff mode. |
11707
1395a3b6978d
patch 8.0.0736: OptionSet not triggered when entering diff mode
Christian Brabandt <cb@256bit.org>
parents:
11430
diff
changeset
|
1564 set_diff_option(wp, FALSE); |
5102
11d0c6df1d7b
updated for version 7.3.1294
Bram Moolenaar <bram@vim.org>
parents:
4352
diff
changeset
|
1565 |
11d0c6df1d7b
updated for version 7.3.1294
Bram Moolenaar <bram@vim.org>
parents:
4352
diff
changeset
|
1566 if (wp->w_p_diff_saved) |
11d0c6df1d7b
updated for version 7.3.1294
Bram Moolenaar <bram@vim.org>
parents:
4352
diff
changeset
|
1567 { |
6897 | 1568 |
1569 if (wp->w_p_scb) | |
1570 wp->w_p_scb = wp->w_p_scb_save; | |
1571 if (wp->w_p_crb) | |
1572 wp->w_p_crb = wp->w_p_crb_save; | |
23895
e313b6ee2d9c
patch 8.2.2490: 'wrap' option is always reset when starting diff mode
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
1573 if (!(diff_flags & DIFF_FOLLOWWRAP)) |
e313b6ee2d9c
patch 8.2.2490: 'wrap' option is always reset when starting diff mode
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
1574 { |
e313b6ee2d9c
patch 8.2.2490: 'wrap' option is always reset when starting diff mode
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
1575 if (!wp->w_p_wrap) |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1576 wp->w_p_wrap = wp->w_p_wrap_save; |
23895
e313b6ee2d9c
patch 8.2.2490: 'wrap' option is always reset when starting diff mode
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
1577 } |
6897 | 1578 #ifdef FEAT_FOLDING |
5102
11d0c6df1d7b
updated for version 7.3.1294
Bram Moolenaar <bram@vim.org>
parents:
4352
diff
changeset
|
1579 free_string_option(wp->w_p_fdm); |
11430
eba1a8c6e21d
patch 8.0.0599: diff mode is insufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
11129
diff
changeset
|
1580 wp->w_p_fdm = vim_strsave( |
eba1a8c6e21d
patch 8.0.0599: diff mode is insufficiently tested
Christian Brabandt <cb@256bit.org>
parents:
11129
diff
changeset
|
1581 *wp->w_p_fdm_save ? wp->w_p_fdm_save : (char_u*)"manual"); |
5200
b3ff17862b4c
updated for version 7.4a.026
Bram Moolenaar <bram@vim.org>
parents:
5102
diff
changeset
|
1582 |
6897 | 1583 if (wp->w_p_fdc == diff_foldcolumn) |
1584 wp->w_p_fdc = wp->w_p_fdc_save; | |
1585 if (wp->w_p_fdl == 0) | |
1586 wp->w_p_fdl = wp->w_p_fdl_save; | |
1587 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1588 // Only restore 'foldenable' when 'foldmethod' is not |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1589 // "manual", otherwise we continue to show the diff folds. |
6897 | 1590 if (wp->w_p_fen) |
1591 wp->w_p_fen = foldmethodIsManual(wp) ? FALSE | |
1592 : wp->w_p_fen_save; | |
1593 | |
1594 foldUpdateAll(wp); | |
1595 #endif | |
5200
b3ff17862b4c
updated for version 7.4a.026
Bram Moolenaar <bram@vim.org>
parents:
5102
diff
changeset
|
1596 } |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1597 // remove filler lines |
10005
4b4ba6589a98
commit https://github.com/vim/vim/commit/e67d546f3c691139e6d3d33f36724d98aec04c14
Christian Brabandt <cb@256bit.org>
parents:
9719
diff
changeset
|
1598 wp->w_topfill = 0; |
4b4ba6589a98
commit https://github.com/vim/vim/commit/e67d546f3c691139e6d3d33f36724d98aec04c14
Christian Brabandt <cb@256bit.org>
parents:
9719
diff
changeset
|
1599 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1600 // make sure topline is not halfway a fold and cursor is |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1601 // invalidated |
10005
4b4ba6589a98
commit https://github.com/vim/vim/commit/e67d546f3c691139e6d3d33f36724d98aec04c14
Christian Brabandt <cb@256bit.org>
parents:
9719
diff
changeset
|
1602 changed_window_setting_win(wp); |
5200
b3ff17862b4c
updated for version 7.4a.026
Bram Moolenaar <bram@vim.org>
parents:
5102
diff
changeset
|
1603 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1604 // Note: 'sbo' is not restored, it's a global option. |
16 | 1605 diff_buf_adjust(wp); |
1606 } | |
1607 diffwin |= wp->w_p_diff; | |
1608 } | |
1609 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1610 // Also remove hidden buffers from the list. |
10821
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
1611 if (eap->forceit) |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
1612 diff_buf_clear(); |
d9e48fb5142f
patch 8.0.0300: cannot stop diffing hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
10295
diff
changeset
|
1613 |
18590
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1614 if (!diffwin) |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1615 { |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1616 diff_need_update = FALSE; |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1617 curtab->tp_diff_invalid = FALSE; |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1618 curtab->tp_diff_update = FALSE; |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1619 diff_clear(curtab); |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1620 } |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
1621 |
26771
fc859aea8cec
patch 8.2.3914: various spelling mistakes in comments
Bram Moolenaar <Bram@vim.org>
parents:
26602
diff
changeset
|
1622 // Remove "hor" from 'scrollopt' if there are no diff windows left. |
16 | 1623 if (!diffwin && vim_strchr(p_sbo, 'h') != NULL) |
1624 do_cmdline_cmd((char_u *)"set sbo-=hor"); | |
1625 } | |
1626 | |
1627 /* | |
7 | 1628 * Read the diff output and add each entry to the diff list. |
1629 */ | |
1630 static void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
1631 diff_read( |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1632 int idx_orig, // idx of original file |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1633 int idx_new, // idx of new file |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1634 diffio_T *dio) // diff output |
7 | 1635 { |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1636 FILE *fd = NULL; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1637 int line_idx = 0; |
7 | 1638 diff_T *dprev = NULL; |
672 | 1639 diff_T *dp = curtab->tp_first_diff; |
7 | 1640 diff_T *dn, *dpl; |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1641 diffout_T *dout = &dio->dio_diff; |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1642 char_u linebuf[LBUFLEN]; // only need to hold the diff line |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1643 char_u *line; |
7 | 1644 long off; |
1645 int i; | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1646 int notset = TRUE; // block "*dp" not set yet |
26829
88a33cf5aeb6
patch 8.2.3943: compiler warning from gcc for uninitialized variable
Bram Moolenaar <Bram@vim.org>
parents:
26805
diff
changeset
|
1647 diffhunk_T *hunk = NULL; // init to avoid gcc warning |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1648 |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1649 enum { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1650 DIFF_ED, |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1651 DIFF_UNIFIED, |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1652 DIFF_NONE |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1653 } diffstyle = DIFF_NONE; |
7 | 1654 |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1655 if (dout->dout_fname == NULL) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1656 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1657 diffstyle = DIFF_UNIFIED; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1658 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1659 else |
7 | 1660 { |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1661 fd = mch_fopen((char *)dout->dout_fname, "r"); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1662 if (fd == NULL) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1663 { |
26602
fac6673086df
patch 8.2.3830: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26044
diff
changeset
|
1664 emsg(_(e_cannot_read_diff_output)); |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1665 return; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1666 } |
7 | 1667 } |
1668 | |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1669 if (!dio->dio_internal) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1670 { |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1671 hunk = ALLOC_ONE(diffhunk_T); |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1672 if (hunk == NULL) |
28197
e4d25cbc2bd7
patch 8.2.4624: old Coverity warning for resource leak
Bram Moolenaar <Bram@vim.org>
parents:
26966
diff
changeset
|
1673 { |
e4d25cbc2bd7
patch 8.2.4624: old Coverity warning for resource leak
Bram Moolenaar <Bram@vim.org>
parents:
26966
diff
changeset
|
1674 if (fd != NULL) |
e4d25cbc2bd7
patch 8.2.4624: old Coverity warning for resource leak
Bram Moolenaar <Bram@vim.org>
parents:
26966
diff
changeset
|
1675 fclose(fd); |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1676 return; |
28197
e4d25cbc2bd7
patch 8.2.4624: old Coverity warning for resource leak
Bram Moolenaar <Bram@vim.org>
parents:
26966
diff
changeset
|
1677 } |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1678 } |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1679 |
7 | 1680 for (;;) |
1681 { | |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1682 if (dio->dio_internal) |
7 | 1683 { |
31804
50555279168b
patch 9.0.1234: the code style has to be checked manually
Bram Moolenaar <Bram@vim.org>
parents:
31667
diff
changeset
|
1684 if (line_idx >= dout->dout_ga.ga_len) |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1685 break; // did last line |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1686 hunk = ((diffhunk_T **)dout->dout_ga.ga_data)[line_idx++]; |
7 | 1687 } |
1688 else | |
1689 { | |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1690 if (fd == NULL) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1691 { |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1692 if (line_idx >= dout->dout_ga.ga_len) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1693 break; // did last line |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1694 line = ((char_u **)dout->dout_ga.ga_data)[line_idx++]; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1695 } |
14726
655f00c29c58
patch 8.1.0375: cannot use diff mode with Cygwin diff.exe
Christian Brabandt <cb@256bit.org>
parents:
14716
diff
changeset
|
1696 else |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1697 { |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1698 if (vim_fgets(linebuf, LBUFLEN, fd)) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1699 break; // end of file |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1700 line = linebuf; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1701 } |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1702 |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1703 if (diffstyle == DIFF_NONE) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1704 { |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1705 // Determine diff style. |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1706 // ed like diff looks like this: |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1707 // {first}[,{last}]c{first}[,{last}] |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1708 // {first}a{first}[,{last}] |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1709 // {first}[,{last}]d{first} |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1710 // |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1711 // unified diff looks like this: |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1712 // --- file1 2018-03-20 13:23:35.783153140 +0100 |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1713 // +++ file2 2018-03-20 13:23:41.183156066 +0100 |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1714 // @@ -1,3 +1,5 @@ |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1715 if (isdigit(*line)) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1716 diffstyle = DIFF_ED; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1717 else if ((STRNCMP(line, "@@ ", 3) == 0)) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1718 diffstyle = DIFF_UNIFIED; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1719 else if ((STRNCMP(line, "--- ", 4) == 0) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1720 && (vim_fgets(linebuf, LBUFLEN, fd) == 0) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1721 && (STRNCMP(line, "+++ ", 4) == 0) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1722 && (vim_fgets(linebuf, LBUFLEN, fd) == 0) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1723 && (STRNCMP(line, "@@ ", 3) == 0)) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1724 diffstyle = DIFF_UNIFIED; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1725 else |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1726 // Format not recognized yet, skip over this line. Cygwin |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1727 // diff may put a warning at the start of the file. |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1728 continue; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1729 } |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1730 |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1731 if (diffstyle == DIFF_ED) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1732 { |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1733 if (!isdigit(*line)) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1734 continue; // not the start of a diff block |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1735 if (parse_diff_ed(line, hunk) == FAIL) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1736 continue; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1737 } |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1738 else if (diffstyle == DIFF_UNIFIED) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1739 { |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1740 if (STRNCMP(line, "@@ ", 3) != 0) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1741 continue; // not the start of a diff block |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1742 if (parse_diff_unified(line, hunk) == FAIL) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1743 continue; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1744 } |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1745 else |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1746 { |
26966
ac75c145f0a9
patch 8.2.4012: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26962
diff
changeset
|
1747 emsg(_(e_invalid_diff_format)); |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1748 break; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1749 } |
7 | 1750 } |
1751 | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1752 // Go over blocks before the change, for which orig and new are equal. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1753 // Copy blocks from orig to new. |
7 | 1754 while (dp != NULL |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1755 && hunk->lnum_orig > dp->df_lnum[idx_orig] |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1756 + dp->df_count[idx_orig]) |
7 | 1757 { |
1758 if (notset) | |
1759 diff_copy_entry(dprev, dp, idx_orig, idx_new); | |
1760 dprev = dp; | |
1761 dp = dp->df_next; | |
1762 notset = TRUE; | |
1763 } | |
1764 | |
1765 if (dp != NULL | |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1766 && hunk->lnum_orig <= dp->df_lnum[idx_orig] |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1767 + dp->df_count[idx_orig] |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1768 && hunk->lnum_orig + hunk->count_orig >= dp->df_lnum[idx_orig]) |
7 | 1769 { |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1770 // New block overlaps with existing block(s). |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1771 // First find last block that overlaps. |
7 | 1772 for (dpl = dp; dpl->df_next != NULL; dpl = dpl->df_next) |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1773 if (hunk->lnum_orig + hunk->count_orig |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1774 < dpl->df_next->df_lnum[idx_orig]) |
7 | 1775 break; |
1776 | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1777 // If the newly found block starts before the old one, set the |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1778 // start back a number of lines. |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1779 off = dp->df_lnum[idx_orig] - hunk->lnum_orig; |
7 | 1780 if (off > 0) |
1781 { | |
1782 for (i = idx_orig; i < idx_new; ++i) | |
672 | 1783 if (curtab->tp_diffbuf[i] != NULL) |
7 | 1784 dp->df_lnum[i] -= off; |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1785 dp->df_lnum[idx_new] = hunk->lnum_new; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1786 dp->df_count[idx_new] = hunk->count_new; |
7 | 1787 } |
1788 else if (notset) | |
1789 { | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1790 // new block inside existing one, adjust new block |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1791 dp->df_lnum[idx_new] = hunk->lnum_new + off; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1792 dp->df_count[idx_new] = hunk->count_new - off; |
7 | 1793 } |
1794 else | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1795 // second overlap of new block with existing block |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1796 dp->df_count[idx_new] += hunk->count_new - hunk->count_orig |
1519 | 1797 + dpl->df_lnum[idx_orig] + dpl->df_count[idx_orig] |
1798 - (dp->df_lnum[idx_orig] + dp->df_count[idx_orig]); | |
7 | 1799 |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1800 // Adjust the size of the block to include all the lines to the |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1801 // end of the existing block or the new diff, whatever ends last. |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1802 off = (hunk->lnum_orig + hunk->count_orig) |
7 | 1803 - (dpl->df_lnum[idx_orig] + dpl->df_count[idx_orig]); |
1804 if (off < 0) | |
1805 { | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1806 // new change ends in existing block, adjust the end if not |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1807 // done already |
7 | 1808 if (notset) |
1809 dp->df_count[idx_new] += -off; | |
1810 off = 0; | |
1811 } | |
1428 | 1812 for (i = idx_orig; i < idx_new; ++i) |
672 | 1813 if (curtab->tp_diffbuf[i] != NULL) |
7 | 1814 dp->df_count[i] = dpl->df_lnum[i] + dpl->df_count[i] |
1815 - dp->df_lnum[i] + off; | |
1816 | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1817 // Delete the diff blocks that have been merged into one. |
7 | 1818 dn = dp->df_next; |
1819 dp->df_next = dpl->df_next; | |
1820 while (dn != dp->df_next) | |
1821 { | |
1822 dpl = dn->df_next; | |
1823 vim_free(dn); | |
1824 dn = dpl; | |
1825 } | |
1826 } | |
1827 else | |
1828 { | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1829 // Allocate a new diffblock. |
672 | 1830 dp = diff_alloc_new(curtab, dprev, dp); |
7 | 1831 if (dp == NULL) |
840 | 1832 goto done; |
7 | 1833 |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1834 dp->df_lnum[idx_orig] = hunk->lnum_orig; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1835 dp->df_count[idx_orig] = hunk->count_orig; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1836 dp->df_lnum[idx_new] = hunk->lnum_new; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1837 dp->df_count[idx_new] = hunk->count_new; |
7 | 1838 |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1839 // Set values for other buffers, these must be equal to the |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1840 // original buffer, otherwise there would have been a change |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1841 // already. |
7 | 1842 for (i = idx_orig + 1; i < idx_new; ++i) |
672 | 1843 if (curtab->tp_diffbuf[i] != NULL) |
7 | 1844 diff_copy_entry(dprev, dp, idx_orig, i); |
1845 } | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1846 notset = FALSE; // "*dp" has been set |
7 | 1847 } |
1848 | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1849 // for remaining diff blocks orig and new are equal |
7 | 1850 while (dp != NULL) |
1851 { | |
1852 if (notset) | |
1853 diff_copy_entry(dprev, dp, idx_orig, idx_new); | |
1854 dprev = dp; | |
1855 dp = dp->df_next; | |
1856 notset = TRUE; | |
1857 } | |
1858 | |
840 | 1859 done: |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1860 if (!dio->dio_internal) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1861 vim_free(hunk); |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
1862 |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1863 if (fd != NULL) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
1864 fclose(fd); |
7 | 1865 } |
1866 | |
1867 /* | |
1868 * Copy an entry at "dp" from "idx_orig" to "idx_new". | |
1869 */ | |
1870 static void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
1871 diff_copy_entry( |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
1872 diff_T *dprev, |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
1873 diff_T *dp, |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
1874 int idx_orig, |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
1875 int idx_new) |
7 | 1876 { |
1877 long off; | |
1878 | |
1879 if (dprev == NULL) | |
1880 off = 0; | |
1881 else | |
1882 off = (dprev->df_lnum[idx_orig] + dprev->df_count[idx_orig]) | |
1883 - (dprev->df_lnum[idx_new] + dprev->df_count[idx_new]); | |
1884 dp->df_lnum[idx_new] = dp->df_lnum[idx_orig] - off; | |
1885 dp->df_count[idx_new] = dp->df_count[idx_orig]; | |
1886 } | |
1887 | |
1888 /* | |
672 | 1889 * Clear the list of diffblocks for tab page "tp". |
7 | 1890 */ |
358 | 1891 void |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
1892 diff_clear(tabpage_T *tp) |
7 | 1893 { |
1894 diff_T *p, *next_p; | |
1895 | |
672 | 1896 for (p = tp->tp_first_diff; p != NULL; p = next_p) |
7 | 1897 { |
1898 next_p = p->df_next; | |
1899 vim_free(p); | |
1900 } | |
672 | 1901 tp->tp_first_diff = NULL; |
7 | 1902 } |
1903 | |
1904 /* | |
1905 * Check diff status for line "lnum" in buffer "buf": | |
1906 * Returns 0 for nothing special | |
1907 * Returns -1 for a line that should be highlighted as changed. | |
1908 * Returns -2 for a line that should be highlighted as added/deleted. | |
1909 * Returns > 0 for inserting that many filler lines above it (never happens | |
1910 * when 'diffopt' doesn't contain "filler"). | |
1911 * This should only be used for windows where 'diff' is set. | |
1912 */ | |
1913 int | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
1914 diff_check(win_T *wp, linenr_T lnum) |
7 | 1915 { |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1916 int idx; // index in tp_diffbuf[] for this buffer |
7 | 1917 diff_T *dp; |
1918 int maxcount; | |
1919 int i; | |
1920 buf_T *buf = wp->w_buffer; | |
1921 int cmp; | |
1922 | |
672 | 1923 if (curtab->tp_diff_invalid) |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1924 ex_diffupdate(NULL); // update after a big change |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1925 |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1926 if (curtab->tp_first_diff == NULL || !wp->w_p_diff) // no diffs at all |
7 | 1927 return 0; |
1928 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1929 // safety check: "lnum" must be a buffer line |
7 | 1930 if (lnum < 1 || lnum > buf->b_ml.ml_line_count + 1) |
1931 return 0; | |
1932 | |
1933 idx = diff_buf_idx(buf); | |
1934 if (idx == DB_COUNT) | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1935 return 0; // no diffs for buffer "buf" |
7 | 1936 |
1937 #ifdef FEAT_FOLDING | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1938 // A closed fold never has filler lines. |
7 | 1939 if (hasFoldingWin(wp, lnum, NULL, NULL, TRUE, NULL)) |
1940 return 0; | |
1941 #endif | |
1942 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1943 // search for a change that includes "lnum" in the list of diffblocks. |
19888
435726a03481
patch 8.2.0500: using the same loop in many places
Bram Moolenaar <Bram@vim.org>
parents:
18777
diff
changeset
|
1944 FOR_ALL_DIFFBLOCKS_IN_TAB(curtab, dp) |
7 | 1945 if (lnum <= dp->df_lnum[idx] + dp->df_count[idx]) |
1946 break; | |
1947 if (dp == NULL || lnum < dp->df_lnum[idx]) | |
1948 return 0; | |
1949 | |
1950 if (lnum < dp->df_lnum[idx] + dp->df_count[idx]) | |
1951 { | |
1952 int zero = FALSE; | |
1953 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1954 // Changed or inserted line. If the other buffers have a count of |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1955 // zero, the lines were inserted. If the other buffers have the same |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1956 // count, check if the lines are identical. |
7 | 1957 cmp = FALSE; |
1958 for (i = 0; i < DB_COUNT; ++i) | |
672 | 1959 if (i != idx && curtab->tp_diffbuf[i] != NULL) |
7 | 1960 { |
1961 if (dp->df_count[i] == 0) | |
1962 zero = TRUE; | |
1963 else | |
1964 { | |
1965 if (dp->df_count[i] != dp->df_count[idx]) | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1966 return -1; // nr of lines changed. |
7 | 1967 cmp = TRUE; |
1968 } | |
1969 } | |
1970 if (cmp) | |
1971 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1972 // Compare all lines. If they are equal the lines were inserted |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1973 // in some buffers, deleted in others, but not changed. |
7 | 1974 for (i = 0; i < DB_COUNT; ++i) |
9487
69ed2c9d34a6
commit https://github.com/vim/vim/commit/7c0a2f367f2507669560b1a66423155c70d2e75b
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
1975 if (i != idx && curtab->tp_diffbuf[i] != NULL |
69ed2c9d34a6
commit https://github.com/vim/vim/commit/7c0a2f367f2507669560b1a66423155c70d2e75b
Christian Brabandt <cb@256bit.org>
parents:
9387
diff
changeset
|
1976 && dp->df_count[i] != 0) |
7 | 1977 if (!diff_equal_entry(dp, idx, i)) |
1978 return -1; | |
1979 } | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1980 // If there is no buffer with zero lines then there is no difference |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1981 // any longer. Happens when making a change (or undo) that removes |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1982 // the difference. Can't remove the entry here, we might be halfway |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1983 // updating the window. Just report the text as unchanged. Other |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1984 // windows might still show the change though. |
7 | 1985 if (zero == FALSE) |
1986 return 0; | |
1987 return -2; | |
1988 } | |
1989 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1990 // If 'diffopt' doesn't contain "filler", return 0. |
7 | 1991 if (!(diff_flags & DIFF_FILLER)) |
1992 return 0; | |
1993 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1994 // Insert filler lines above the line just below the change. Will return |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
1995 // 0 when this buf had the max count. |
7 | 1996 maxcount = 0; |
1997 for (i = 0; i < DB_COUNT; ++i) | |
672 | 1998 if (curtab->tp_diffbuf[i] != NULL && dp->df_count[i] > maxcount) |
7 | 1999 maxcount = dp->df_count[i]; |
2000 return maxcount - dp->df_count[idx]; | |
2001 } | |
2002 | |
2003 /* | |
2004 * Compare two entries in diff "*dp" and return TRUE if they are equal. | |
2005 */ | |
2006 static int | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
2007 diff_equal_entry(diff_T *dp, int idx1, int idx2) |
7 | 2008 { |
2009 int i; | |
2010 char_u *line; | |
2011 int cmp; | |
2012 | |
2013 if (dp->df_count[idx1] != dp->df_count[idx2]) | |
2014 return FALSE; | |
672 | 2015 if (diff_check_sanity(curtab, dp) == FAIL) |
7 | 2016 return FALSE; |
2017 for (i = 0; i < dp->df_count[idx1]; ++i) | |
2018 { | |
672 | 2019 line = vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx1], |
7 | 2020 dp->df_lnum[idx1] + i, FALSE)); |
2021 if (line == NULL) | |
2022 return FALSE; | |
672 | 2023 cmp = diff_cmp(line, ml_get_buf(curtab->tp_diffbuf[idx2], |
7 | 2024 dp->df_lnum[idx2] + i, FALSE)); |
2025 vim_free(line); | |
2026 if (cmp != 0) | |
2027 return FALSE; | |
2028 } | |
2029 return TRUE; | |
2030 } | |
2031 | |
2032 /* | |
12333
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2033 * Compare the characters at "p1" and "p2". If they are equal (possibly |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2034 * ignoring case) return TRUE and set "len" to the number of bytes. |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2035 */ |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2036 static int |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2037 diff_equal_char(char_u *p1, char_u *p2, int *len) |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2038 { |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2039 int l = (*mb_ptr2len)(p1); |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2040 |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2041 if (l != (*mb_ptr2len)(p2)) |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2042 return FALSE; |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2043 if (l > 1) |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2044 { |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2045 if (STRNCMP(p1, p2, l) != 0 |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2046 && (!enc_utf8 |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2047 || !(diff_flags & DIFF_ICASE) |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2048 || utf_fold(utf_ptr2char(p1)) |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2049 != utf_fold(utf_ptr2char(p2)))) |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2050 return FALSE; |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2051 *len = l; |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2052 } |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2053 else |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2054 { |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2055 if ((*p1 != *p2) |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2056 && (!(diff_flags & DIFF_ICASE) |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2057 || TOLOWER_LOC(*p1) != TOLOWER_LOC(*p2))) |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2058 return FALSE; |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2059 *len = 1; |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2060 } |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2061 return TRUE; |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2062 } |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2063 |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2064 /* |
7 | 2065 * Compare strings "s1" and "s2" according to 'diffopt'. |
2066 * Return non-zero when they are different. | |
2067 */ | |
2068 static int | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
2069 diff_cmp(char_u *s1, char_u *s2) |
7 | 2070 { |
2071 char_u *p1, *p2; | |
2072 int l; | |
2073 | |
14762
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2074 if ((diff_flags & DIFF_IBLANK) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2075 && (*skipwhite(s1) == NUL || *skipwhite(s2) == NUL)) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2076 return 0; |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2077 |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2078 if ((diff_flags & (DIFF_ICASE | ALL_WHITE_DIFF)) == 0) |
7 | 2079 return STRCMP(s1, s2); |
14762
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2080 if ((diff_flags & DIFF_ICASE) && !(diff_flags & ALL_WHITE_DIFF)) |
7 | 2081 return MB_STRICMP(s1, s2); |
2082 | |
2083 p1 = s1; | |
2084 p2 = s2; | |
14762
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2085 |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2086 // Ignore white space changes and possibly ignore case. |
7 | 2087 while (*p1 != NUL && *p2 != NUL) |
2088 { | |
14762
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2089 if (((diff_flags & DIFF_IWHITE) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2090 && VIM_ISWHITE(*p1) && VIM_ISWHITE(*p2)) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2091 || ((diff_flags & DIFF_IWHITEALL) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2092 && (VIM_ISWHITE(*p1) || VIM_ISWHITE(*p2)))) |
7 | 2093 { |
2094 p1 = skipwhite(p1); | |
2095 p2 = skipwhite(p2); | |
2096 } | |
2097 else | |
2098 { | |
12333
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2099 if (!diff_equal_char(p1, p2, &l)) |
7 | 2100 break; |
12333
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2101 p1 += l; |
dea5dda9ef30
patch 8.0.1046: code duplication in diff mode
Christian Brabandt <cb@256bit.org>
parents:
12315
diff
changeset
|
2102 p2 += l; |
7 | 2103 } |
2104 } | |
2105 | |
14762
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2106 // Ignore trailing white space. |
7 | 2107 p1 = skipwhite(p1); |
2108 p2 = skipwhite(p2); | |
2109 if (*p1 != NUL || *p2 != NUL) | |
2110 return 1; | |
2111 return 0; | |
2112 } | |
2113 | |
2114 /* | |
2115 * Return the number of filler lines above "lnum". | |
2116 */ | |
2117 int | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
2118 diff_check_fill(win_T *wp, linenr_T lnum) |
7 | 2119 { |
2120 int n; | |
2121 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2122 // be quick when there are no filler lines |
7 | 2123 if (!(diff_flags & DIFF_FILLER)) |
2124 return 0; | |
2125 n = diff_check(wp, lnum); | |
2126 if (n <= 0) | |
2127 return 0; | |
2128 return n; | |
2129 } | |
2130 | |
2131 /* | |
2132 * Set the topline of "towin" to match the position in "fromwin", so that they | |
2133 * show the same diff'ed lines. | |
2134 */ | |
2135 void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
2136 diff_set_topline(win_T *fromwin, win_T *towin) |
7 | 2137 { |
1519 | 2138 buf_T *frombuf = fromwin->w_buffer; |
7 | 2139 linenr_T lnum = fromwin->w_topline; |
1519 | 2140 int fromidx; |
2141 int toidx; | |
7 | 2142 diff_T *dp; |
1519 | 2143 int max_count; |
7 | 2144 int i; |
2145 | |
1519 | 2146 fromidx = diff_buf_idx(frombuf); |
2147 if (fromidx == DB_COUNT) | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2148 return; // safety check |
7 | 2149 |
672 | 2150 if (curtab->tp_diff_invalid) |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2151 ex_diffupdate(NULL); // update after a big change |
7 | 2152 |
2153 towin->w_topfill = 0; | |
2154 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2155 // search for a change that includes "lnum" in the list of diffblocks. |
19888
435726a03481
patch 8.2.0500: using the same loop in many places
Bram Moolenaar <Bram@vim.org>
parents:
18777
diff
changeset
|
2156 FOR_ALL_DIFFBLOCKS_IN_TAB(curtab, dp) |
1519 | 2157 if (lnum <= dp->df_lnum[fromidx] + dp->df_count[fromidx]) |
7 | 2158 break; |
2159 if (dp == NULL) | |
2160 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2161 // After last change, compute topline relative to end of file; no |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2162 // filler lines. |
7 | 2163 towin->w_topline = towin->w_buffer->b_ml.ml_line_count |
1519 | 2164 - (frombuf->b_ml.ml_line_count - lnum); |
7 | 2165 } |
2166 else | |
2167 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2168 // Find index for "towin". |
1519 | 2169 toidx = diff_buf_idx(towin->w_buffer); |
2170 if (toidx == DB_COUNT) | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2171 return; // safety check |
7 | 2172 |
1519 | 2173 towin->w_topline = lnum + (dp->df_lnum[toidx] - dp->df_lnum[fromidx]); |
2174 if (lnum >= dp->df_lnum[fromidx]) | |
7 | 2175 { |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2176 // Inside a change: compute filler lines. With three or more |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2177 // buffers we need to know the largest count. |
1519 | 2178 max_count = 0; |
2179 for (i = 0; i < DB_COUNT; ++i) | |
2180 if (curtab->tp_diffbuf[i] != NULL | |
2181 && max_count < dp->df_count[i]) | |
2182 max_count = dp->df_count[i]; | |
2183 | |
2184 if (dp->df_count[toidx] == dp->df_count[fromidx]) | |
2185 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2186 // same number of lines: use same filler count |
7 | 2187 towin->w_topfill = fromwin->w_topfill; |
1519 | 2188 } |
2189 else if (dp->df_count[toidx] > dp->df_count[fromidx]) | |
7 | 2190 { |
1519 | 2191 if (lnum == dp->df_lnum[fromidx] + dp->df_count[fromidx]) |
2192 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2193 // more lines in towin and fromwin doesn't show diff |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2194 // lines, only filler lines |
1519 | 2195 if (max_count - fromwin->w_topfill >= dp->df_count[toidx]) |
2196 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2197 // towin also only shows filler lines |
1519 | 2198 towin->w_topline = dp->df_lnum[toidx] |
2199 + dp->df_count[toidx]; | |
2200 towin->w_topfill = fromwin->w_topfill; | |
2201 } | |
2202 else | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2203 // towin still has some diff lines to show |
1519 | 2204 towin->w_topline = dp->df_lnum[toidx] |
2205 + max_count - fromwin->w_topfill; | |
2206 } | |
7 | 2207 } |
1519 | 2208 else if (towin->w_topline >= dp->df_lnum[toidx] |
2209 + dp->df_count[toidx]) | |
7 | 2210 { |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2211 // less lines in towin and no diff lines to show: compute |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2212 // filler lines |
1519 | 2213 towin->w_topline = dp->df_lnum[toidx] + dp->df_count[toidx]; |
2214 if (diff_flags & DIFF_FILLER) | |
7 | 2215 { |
1519 | 2216 if (lnum == dp->df_lnum[fromidx] + dp->df_count[fromidx]) |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2217 // fromwin is also out of diff lines |
1519 | 2218 towin->w_topfill = fromwin->w_topfill; |
2219 else | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2220 // fromwin has some diff lines |
1519 | 2221 towin->w_topfill = dp->df_lnum[fromidx] |
2222 + max_count - lnum; | |
7 | 2223 } |
2224 } | |
2225 } | |
2226 } | |
2227 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2228 // safety check (if diff info gets outdated strange things may happen) |
7 | 2229 towin->w_botfill = FALSE; |
2230 if (towin->w_topline > towin->w_buffer->b_ml.ml_line_count) | |
2231 { | |
2232 towin->w_topline = towin->w_buffer->b_ml.ml_line_count; | |
2233 towin->w_botfill = TRUE; | |
2234 } | |
2235 if (towin->w_topline < 1) | |
2236 { | |
2237 towin->w_topline = 1; | |
2238 towin->w_topfill = 0; | |
2239 } | |
2240 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2241 // When w_topline changes need to recompute w_botline and cursor position |
7 | 2242 invalidate_botline_win(towin); |
2243 changed_line_abv_curs_win(towin); | |
2244 | |
2245 check_topfill(towin, FALSE); | |
2246 #ifdef FEAT_FOLDING | |
2247 (void)hasFoldingWin(towin, towin->w_topline, &towin->w_topline, | |
2248 NULL, TRUE, NULL); | |
2249 #endif | |
2250 } | |
2251 | |
2252 /* | |
2253 * This is called when 'diffopt' is changed. | |
2254 */ | |
2255 int | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
2256 diffopt_changed(void) |
7 | 2257 { |
2258 char_u *p; | |
2259 int diff_context_new = 6; | |
2260 int diff_flags_new = 0; | |
764 | 2261 int diff_foldcolumn_new = 2; |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2262 long diff_algorithm_new = 0; |
15103
9339601e7a31
patch 8.1.0562: parsing of 'diffopt' is slightly wrong
Bram Moolenaar <Bram@vim.org>
parents:
15004
diff
changeset
|
2263 long diff_indent_heuristic = 0; |
672 | 2264 tabpage_T *tp; |
7 | 2265 |
2266 p = p_dip; | |
2267 while (*p != NUL) | |
2268 { | |
2269 if (STRNCMP(p, "filler", 6) == 0) | |
2270 { | |
2271 p += 6; | |
2272 diff_flags_new |= DIFF_FILLER; | |
2273 } | |
2274 else if (STRNCMP(p, "context:", 8) == 0 && VIM_ISDIGIT(p[8])) | |
2275 { | |
2276 p += 8; | |
2277 diff_context_new = getdigits(&p); | |
2278 } | |
14762
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2279 else if (STRNCMP(p, "iblank", 6) == 0) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2280 { |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2281 p += 6; |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2282 diff_flags_new |= DIFF_IBLANK; |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2283 } |
7 | 2284 else if (STRNCMP(p, "icase", 5) == 0) |
2285 { | |
2286 p += 5; | |
2287 diff_flags_new |= DIFF_ICASE; | |
2288 } | |
14762
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2289 else if (STRNCMP(p, "iwhiteall", 9) == 0) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2290 { |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2291 p += 9; |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2292 diff_flags_new |= DIFF_IWHITEALL; |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2293 } |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2294 else if (STRNCMP(p, "iwhiteeol", 9) == 0) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2295 { |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2296 p += 9; |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2297 diff_flags_new |= DIFF_IWHITEEOL; |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2298 } |
7 | 2299 else if (STRNCMP(p, "iwhite", 6) == 0) |
2300 { | |
2301 p += 6; | |
2302 diff_flags_new |= DIFF_IWHITE; | |
2303 } | |
764 | 2304 else if (STRNCMP(p, "horizontal", 10) == 0) |
2305 { | |
2306 p += 10; | |
2307 diff_flags_new |= DIFF_HORIZONTAL; | |
2308 } | |
2309 else if (STRNCMP(p, "vertical", 8) == 0) | |
2310 { | |
2311 p += 8; | |
2312 diff_flags_new |= DIFF_VERTICAL; | |
2313 } | |
2314 else if (STRNCMP(p, "foldcolumn:", 11) == 0 && VIM_ISDIGIT(p[11])) | |
2315 { | |
2316 p += 11; | |
2317 diff_foldcolumn_new = getdigits(&p); | |
2318 } | |
12971
ca3cb1997f08
patch 8.0.1361: some users don't want to diff with hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
12353
diff
changeset
|
2319 else if (STRNCMP(p, "hiddenoff", 9) == 0) |
ca3cb1997f08
patch 8.0.1361: some users don't want to diff with hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
12353
diff
changeset
|
2320 { |
ca3cb1997f08
patch 8.0.1361: some users don't want to diff with hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
12353
diff
changeset
|
2321 p += 9; |
ca3cb1997f08
patch 8.0.1361: some users don't want to diff with hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
12353
diff
changeset
|
2322 diff_flags_new |= DIFF_HIDDEN_OFF; |
ca3cb1997f08
patch 8.0.1361: some users don't want to diff with hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
12353
diff
changeset
|
2323 } |
18590
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2324 else if (STRNCMP(p, "closeoff", 8) == 0) |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2325 { |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2326 p += 8; |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2327 diff_flags_new |= DIFF_CLOSE_OFF; |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2328 } |
23895
e313b6ee2d9c
patch 8.2.2490: 'wrap' option is always reset when starting diff mode
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
2329 else if (STRNCMP(p, "followwrap", 10) == 0) |
e313b6ee2d9c
patch 8.2.2490: 'wrap' option is always reset when starting diff mode
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
2330 { |
e313b6ee2d9c
patch 8.2.2490: 'wrap' option is always reset when starting diff mode
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
2331 p += 10; |
e313b6ee2d9c
patch 8.2.2490: 'wrap' option is always reset when starting diff mode
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
2332 diff_flags_new |= DIFF_FOLLOWWRAP; |
e313b6ee2d9c
patch 8.2.2490: 'wrap' option is always reset when starting diff mode
Bram Moolenaar <Bram@vim.org>
parents:
22699
diff
changeset
|
2333 } |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2334 else if (STRNCMP(p, "indent-heuristic", 16) == 0) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2335 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2336 p += 16; |
15103
9339601e7a31
patch 8.1.0562: parsing of 'diffopt' is slightly wrong
Bram Moolenaar <Bram@vim.org>
parents:
15004
diff
changeset
|
2337 diff_indent_heuristic = XDF_INDENT_HEURISTIC; |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2338 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2339 else if (STRNCMP(p, "internal", 8) == 0) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2340 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2341 p += 8; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2342 diff_flags_new |= DIFF_INTERNAL; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2343 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2344 else if (STRNCMP(p, "algorithm:", 10) == 0) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2345 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2346 p += 10; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2347 if (STRNCMP(p, "myers", 5) == 0) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2348 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2349 p += 5; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2350 diff_algorithm_new = 0; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2351 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2352 else if (STRNCMP(p, "minimal", 7) == 0) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2353 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2354 p += 7; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2355 diff_algorithm_new = XDF_NEED_MINIMAL; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2356 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2357 else if (STRNCMP(p, "patience", 8) == 0) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2358 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2359 p += 8; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2360 diff_algorithm_new = XDF_PATIENCE_DIFF; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2361 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2362 else if (STRNCMP(p, "histogram", 9) == 0) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2363 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2364 p += 9; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2365 diff_algorithm_new = XDF_HISTOGRAM_DIFF; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2366 } |
15004
9c2352253376
patch 8.1.0513: no error for set diffopt+=algorithm:
Bram Moolenaar <Bram@vim.org>
parents:
14982
diff
changeset
|
2367 else |
9c2352253376
patch 8.1.0513: no error for set diffopt+=algorithm:
Bram Moolenaar <Bram@vim.org>
parents:
14982
diff
changeset
|
2368 return FAIL; |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2369 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2370 |
7 | 2371 if (*p != ',' && *p != NUL) |
2372 return FAIL; | |
2373 if (*p == ',') | |
2374 ++p; | |
2375 } | |
2376 | |
15103
9339601e7a31
patch 8.1.0562: parsing of 'diffopt' is slightly wrong
Bram Moolenaar <Bram@vim.org>
parents:
15004
diff
changeset
|
2377 diff_algorithm_new |= diff_indent_heuristic; |
9339601e7a31
patch 8.1.0562: parsing of 'diffopt' is slightly wrong
Bram Moolenaar <Bram@vim.org>
parents:
15004
diff
changeset
|
2378 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2379 // Can't have both "horizontal" and "vertical". |
764 | 2380 if ((diff_flags_new & DIFF_HORIZONTAL) && (diff_flags_new & DIFF_VERTICAL)) |
2381 return FAIL; | |
2382 | |
14780
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
2383 // If flags were added or removed, or the algorithm was changed, need to |
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
2384 // update the diff. |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2385 if (diff_flags != diff_flags_new || diff_algorithm != diff_algorithm_new) |
9649
fd9727ae3c49
commit https://github.com/vim/vim/commit/2932359000b2f918d5fade79ea4d124d5943cd07
Christian Brabandt <cb@256bit.org>
parents:
9487
diff
changeset
|
2386 FOR_ALL_TABPAGES(tp) |
672 | 2387 tp->tp_diff_invalid = TRUE; |
7 | 2388 |
2389 diff_flags = diff_flags_new; | |
15900
360c93a884d0
patch 8.1.0956: using context:0 in 'diffopt' does not work well
Bram Moolenaar <Bram@vim.org>
parents:
15840
diff
changeset
|
2390 diff_context = diff_context_new == 0 ? 1 : diff_context_new; |
764 | 2391 diff_foldcolumn = diff_foldcolumn_new; |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
2392 diff_algorithm = diff_algorithm_new; |
7 | 2393 |
2394 diff_redraw(TRUE); | |
2395 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2396 // recompute the scroll binding with the new option value, may |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2397 // remove or add filler lines |
7 | 2398 check_scrollbind((linenr_T)0, 0L); |
2399 | |
2400 return OK; | |
2401 } | |
2402 | |
2403 /* | |
764 | 2404 * Return TRUE if 'diffopt' contains "horizontal". |
2405 */ | |
2406 int | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
2407 diffopt_horizontal(void) |
764 | 2408 { |
2409 return (diff_flags & DIFF_HORIZONTAL) != 0; | |
2410 } | |
2411 | |
2412 /* | |
12971
ca3cb1997f08
patch 8.0.1361: some users don't want to diff with hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
12353
diff
changeset
|
2413 * Return TRUE if 'diffopt' contains "hiddenoff". |
ca3cb1997f08
patch 8.0.1361: some users don't want to diff with hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
12353
diff
changeset
|
2414 */ |
ca3cb1997f08
patch 8.0.1361: some users don't want to diff with hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
12353
diff
changeset
|
2415 int |
ca3cb1997f08
patch 8.0.1361: some users don't want to diff with hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
12353
diff
changeset
|
2416 diffopt_hiddenoff(void) |
ca3cb1997f08
patch 8.0.1361: some users don't want to diff with hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
12353
diff
changeset
|
2417 { |
ca3cb1997f08
patch 8.0.1361: some users don't want to diff with hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
12353
diff
changeset
|
2418 return (diff_flags & DIFF_HIDDEN_OFF) != 0; |
ca3cb1997f08
patch 8.0.1361: some users don't want to diff with hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
12353
diff
changeset
|
2419 } |
ca3cb1997f08
patch 8.0.1361: some users don't want to diff with hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
12353
diff
changeset
|
2420 |
ca3cb1997f08
patch 8.0.1361: some users don't want to diff with hidden buffers
Christian Brabandt <cb@256bit.org>
parents:
12353
diff
changeset
|
2421 /* |
18590
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2422 * Return TRUE if 'diffopt' contains "closeoff". |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2423 */ |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2424 int |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2425 diffopt_closeoff(void) |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2426 { |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2427 return (diff_flags & DIFF_CLOSE_OFF) != 0; |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2428 } |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2429 |
41484f342f80
patch 8.1.2289: after :diffsplit closing the window does not disable diff
Bram Moolenaar <Bram@vim.org>
parents:
18498
diff
changeset
|
2430 /* |
7 | 2431 * Find the difference within a changed line. |
2432 * Returns TRUE if the line was added, no other buffer has it. | |
2433 */ | |
2434 int | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
2435 diff_find_change( |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
2436 win_T *wp, |
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
2437 linenr_T lnum, |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2438 int *startp, // first char of the change |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2439 int *endp) // last char of the change |
7 | 2440 { |
2441 char_u *line_org; | |
2442 char_u *line_new; | |
2443 int i; | |
829 | 2444 int si_org, si_new; |
2445 int ei_org, ei_new; | |
7 | 2446 diff_T *dp; |
2447 int idx; | |
2448 int off; | |
2449 int added = TRUE; | |
12315
40ee9f3d265f
patch 8.0.1037: "icase" of 'diffopt' is not used for highlighting
Christian Brabandt <cb@256bit.org>
parents:
11707
diff
changeset
|
2450 char_u *p1, *p2; |
40ee9f3d265f
patch 8.0.1037: "icase" of 'diffopt' is not used for highlighting
Christian Brabandt <cb@256bit.org>
parents:
11707
diff
changeset
|
2451 int l; |
7 | 2452 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2453 // Make a copy of the line, the next ml_get() will invalidate it. |
7 | 2454 line_org = vim_strsave(ml_get_buf(wp->w_buffer, lnum, FALSE)); |
2455 if (line_org == NULL) | |
2456 return FALSE; | |
2457 | |
2458 idx = diff_buf_idx(wp->w_buffer); | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2459 if (idx == DB_COUNT) // cannot happen |
1074 | 2460 { |
2461 vim_free(line_org); | |
7 | 2462 return FALSE; |
1074 | 2463 } |
7 | 2464 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2465 // search for a change that includes "lnum" in the list of diffblocks. |
19888
435726a03481
patch 8.2.0500: using the same loop in many places
Bram Moolenaar <Bram@vim.org>
parents:
18777
diff
changeset
|
2466 FOR_ALL_DIFFBLOCKS_IN_TAB(curtab, dp) |
7 | 2467 if (lnum <= dp->df_lnum[idx] + dp->df_count[idx]) |
2468 break; | |
672 | 2469 if (dp == NULL || diff_check_sanity(curtab, dp) == FAIL) |
1074 | 2470 { |
2471 vim_free(line_org); | |
7 | 2472 return FALSE; |
1074 | 2473 } |
7 | 2474 |
2475 off = lnum - dp->df_lnum[idx]; | |
2476 | |
2477 for (i = 0; i < DB_COUNT; ++i) | |
672 | 2478 if (curtab->tp_diffbuf[i] != NULL && i != idx) |
7 | 2479 { |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2480 // Skip lines that are not in the other change (filler lines). |
7 | 2481 if (off >= dp->df_count[i]) |
2482 continue; | |
2483 added = FALSE; | |
829 | 2484 line_new = ml_get_buf(curtab->tp_diffbuf[i], |
2485 dp->df_lnum[i] + off, FALSE); | |
7 | 2486 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2487 // Search for start of difference |
829 | 2488 si_org = si_new = 0; |
2489 while (line_org[si_org] != NUL) | |
2490 { | |
14762
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2491 if (((diff_flags & DIFF_IWHITE) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2492 && VIM_ISWHITE(line_org[si_org]) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2493 && VIM_ISWHITE(line_new[si_new])) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2494 || ((diff_flags & DIFF_IWHITEALL) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2495 && (VIM_ISWHITE(line_org[si_org]) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2496 || VIM_ISWHITE(line_new[si_new])))) |
829 | 2497 { |
835 | 2498 si_org = (int)(skipwhite(line_org + si_org) - line_org); |
2499 si_new = (int)(skipwhite(line_new + si_new) - line_new); | |
829 | 2500 } |
2501 else | |
2502 { | |
12315
40ee9f3d265f
patch 8.0.1037: "icase" of 'diffopt' is not used for highlighting
Christian Brabandt <cb@256bit.org>
parents:
11707
diff
changeset
|
2503 if (!diff_equal_char(line_org + si_org, line_new + si_new, |
40ee9f3d265f
patch 8.0.1037: "icase" of 'diffopt' is not used for highlighting
Christian Brabandt <cb@256bit.org>
parents:
11707
diff
changeset
|
2504 &l)) |
829 | 2505 break; |
12315
40ee9f3d265f
patch 8.0.1037: "icase" of 'diffopt' is not used for highlighting
Christian Brabandt <cb@256bit.org>
parents:
11707
diff
changeset
|
2506 si_org += l; |
40ee9f3d265f
patch 8.0.1037: "icase" of 'diffopt' is not used for highlighting
Christian Brabandt <cb@256bit.org>
parents:
11707
diff
changeset
|
2507 si_new += l; |
829 | 2508 } |
2509 } | |
7 | 2510 if (has_mbyte) |
2511 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2512 // Move back to first byte of character in both lines (may |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2513 // have "nn^" in line_org and "n^ in line_new). |
829 | 2514 si_org -= (*mb_head_off)(line_org, line_org + si_org); |
2515 si_new -= (*mb_head_off)(line_new, line_new + si_new); | |
7 | 2516 } |
829 | 2517 if (*startp > si_org) |
2518 *startp = si_org; | |
7 | 2519 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2520 // Search for end of difference, if any. |
829 | 2521 if (line_org[si_org] != NUL || line_new[si_new] != NUL) |
7 | 2522 { |
2523 ei_org = (int)STRLEN(line_org); | |
2524 ei_new = (int)STRLEN(line_new); | |
829 | 2525 while (ei_org >= *startp && ei_new >= si_new |
2526 && ei_org >= 0 && ei_new >= 0) | |
7 | 2527 { |
14762
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2528 if (((diff_flags & DIFF_IWHITE) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2529 && VIM_ISWHITE(line_org[ei_org]) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2530 && VIM_ISWHITE(line_new[ei_new])) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2531 || ((diff_flags & DIFF_IWHITEALL) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2532 && (VIM_ISWHITE(line_org[ei_org]) |
b43ea03bb522
patch 8.1.0393: not all white space difference options available
Christian Brabandt <cb@256bit.org>
parents:
14730
diff
changeset
|
2533 || VIM_ISWHITE(line_new[ei_new])))) |
829 | 2534 { |
2535 while (ei_org >= *startp | |
11129
f4ea50924c6d
patch 8.0.0452: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11121
diff
changeset
|
2536 && VIM_ISWHITE(line_org[ei_org])) |
829 | 2537 --ei_org; |
2538 while (ei_new >= si_new | |
11129
f4ea50924c6d
patch 8.0.0452: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11121
diff
changeset
|
2539 && VIM_ISWHITE(line_new[ei_new])) |
829 | 2540 --ei_new; |
2541 } | |
2542 else | |
2543 { | |
12315
40ee9f3d265f
patch 8.0.1037: "icase" of 'diffopt' is not used for highlighting
Christian Brabandt <cb@256bit.org>
parents:
11707
diff
changeset
|
2544 p1 = line_org + ei_org; |
40ee9f3d265f
patch 8.0.1037: "icase" of 'diffopt' is not used for highlighting
Christian Brabandt <cb@256bit.org>
parents:
11707
diff
changeset
|
2545 p2 = line_new + ei_new; |
40ee9f3d265f
patch 8.0.1037: "icase" of 'diffopt' is not used for highlighting
Christian Brabandt <cb@256bit.org>
parents:
11707
diff
changeset
|
2546 p1 -= (*mb_head_off)(line_org, p1); |
40ee9f3d265f
patch 8.0.1037: "icase" of 'diffopt' is not used for highlighting
Christian Brabandt <cb@256bit.org>
parents:
11707
diff
changeset
|
2547 p2 -= (*mb_head_off)(line_new, p2); |
40ee9f3d265f
patch 8.0.1037: "icase" of 'diffopt' is not used for highlighting
Christian Brabandt <cb@256bit.org>
parents:
11707
diff
changeset
|
2548 if (!diff_equal_char(p1, p2, &l)) |
829 | 2549 break; |
12315
40ee9f3d265f
patch 8.0.1037: "icase" of 'diffopt' is not used for highlighting
Christian Brabandt <cb@256bit.org>
parents:
11707
diff
changeset
|
2550 ei_org -= l; |
40ee9f3d265f
patch 8.0.1037: "icase" of 'diffopt' is not used for highlighting
Christian Brabandt <cb@256bit.org>
parents:
11707
diff
changeset
|
2551 ei_new -= l; |
829 | 2552 } |
7 | 2553 } |
2554 if (*endp < ei_org) | |
2555 *endp = ei_org; | |
2556 } | |
2557 } | |
2558 | |
2559 vim_free(line_org); | |
2560 return added; | |
2561 } | |
2562 | |
2563 #if defined(FEAT_FOLDING) || defined(PROTO) | |
2564 /* | |
2565 * Return TRUE if line "lnum" is not close to a diff block, this line should | |
2566 * be in a fold. | |
2567 * Return FALSE if there are no diff blocks at all in this window. | |
2568 */ | |
2569 int | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
2570 diff_infold(win_T *wp, linenr_T lnum) |
7 | 2571 { |
2572 int i; | |
2573 int idx = -1; | |
2574 int other = FALSE; | |
2575 diff_T *dp; | |
2576 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2577 // Return if 'diff' isn't set. |
7 | 2578 if (!wp->w_p_diff) |
2579 return FALSE; | |
2580 | |
2581 for (i = 0; i < DB_COUNT; ++i) | |
2582 { | |
672 | 2583 if (curtab->tp_diffbuf[i] == wp->w_buffer) |
7 | 2584 idx = i; |
672 | 2585 else if (curtab->tp_diffbuf[i] != NULL) |
7 | 2586 other = TRUE; |
2587 } | |
2588 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2589 // return here if there are no diffs in the window |
7 | 2590 if (idx == -1 || !other) |
2591 return FALSE; | |
2592 | |
672 | 2593 if (curtab->tp_diff_invalid) |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2594 ex_diffupdate(NULL); // update after a big change |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2595 |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2596 // Return if there are no diff blocks. All lines will be folded. |
672 | 2597 if (curtab->tp_first_diff == NULL) |
7 | 2598 return TRUE; |
2599 | |
19888
435726a03481
patch 8.2.0500: using the same loop in many places
Bram Moolenaar <Bram@vim.org>
parents:
18777
diff
changeset
|
2600 FOR_ALL_DIFFBLOCKS_IN_TAB(curtab, dp) |
7 | 2601 { |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2602 // If this change is below the line there can't be any further match. |
7 | 2603 if (dp->df_lnum[idx] - diff_context > lnum) |
2604 break; | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2605 // If this change ends before the line we have a match. |
7 | 2606 if (dp->df_lnum[idx] + dp->df_count[idx] + diff_context > lnum) |
2607 return FALSE; | |
2608 } | |
2609 return TRUE; | |
2610 } | |
2611 #endif | |
2612 | |
2613 /* | |
2614 * "dp" and "do" commands. | |
2615 */ | |
2616 void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
2617 nv_diffgetput(int put, long count) |
7 | 2618 { |
2619 exarg_T ea; | |
6314 | 2620 char_u buf[30]; |
7 | 2621 |
14019
dc67449d648c
patch 8.1.0027: difficult to make a plugin that feeds a line to a job
Christian Brabandt <cb@256bit.org>
parents:
13802
diff
changeset
|
2622 #ifdef FEAT_JOB_CHANNEL |
dc67449d648c
patch 8.1.0027: difficult to make a plugin that feeds a line to a job
Christian Brabandt <cb@256bit.org>
parents:
13802
diff
changeset
|
2623 if (bt_prompt(curbuf)) |
dc67449d648c
patch 8.1.0027: difficult to make a plugin that feeds a line to a job
Christian Brabandt <cb@256bit.org>
parents:
13802
diff
changeset
|
2624 { |
dc67449d648c
patch 8.1.0027: difficult to make a plugin that feeds a line to a job
Christian Brabandt <cb@256bit.org>
parents:
13802
diff
changeset
|
2625 vim_beep(BO_OPER); |
dc67449d648c
patch 8.1.0027: difficult to make a plugin that feeds a line to a job
Christian Brabandt <cb@256bit.org>
parents:
13802
diff
changeset
|
2626 return; |
dc67449d648c
patch 8.1.0027: difficult to make a plugin that feeds a line to a job
Christian Brabandt <cb@256bit.org>
parents:
13802
diff
changeset
|
2627 } |
dc67449d648c
patch 8.1.0027: difficult to make a plugin that feeds a line to a job
Christian Brabandt <cb@256bit.org>
parents:
13802
diff
changeset
|
2628 #endif |
6314 | 2629 if (count == 0) |
2630 ea.arg = (char_u *)""; | |
2631 else | |
2632 { | |
2633 vim_snprintf((char *)buf, 30, "%ld", count); | |
2634 ea.arg = buf; | |
2635 } | |
7 | 2636 if (put) |
2637 ea.cmdidx = CMD_diffput; | |
2638 else | |
2639 ea.cmdidx = CMD_diffget; | |
2640 ea.addr_count = 0; | |
2641 ea.line1 = curwin->w_cursor.lnum; | |
2642 ea.line2 = curwin->w_cursor.lnum; | |
2643 ex_diffgetput(&ea); | |
2644 } | |
2645 | |
2646 /* | |
29367
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2647 * Return TRUE if "diff" appears in the list of diff blocks of the current tab. |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2648 */ |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2649 static int |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2650 valid_diff(diff_T *diff) |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2651 { |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2652 diff_T *dp; |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2653 |
32118
04d9dff67d99
patch 9.0.1390: FOR_ALL_ macros are defined in an unexpected file
Bram Moolenaar <Bram@vim.org>
parents:
31804
diff
changeset
|
2654 FOR_ALL_DIFFBLOCKS_IN_TAB(curtab, dp) |
29367
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2655 if (dp == diff) |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2656 return TRUE; |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2657 return FALSE; |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2658 } |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2659 |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2660 /* |
7 | 2661 * ":diffget" |
2662 * ":diffput" | |
2663 */ | |
2664 void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
2665 ex_diffgetput(exarg_T *eap) |
7 | 2666 { |
2667 linenr_T lnum; | |
2668 int count; | |
2669 linenr_T off = 0; | |
2670 diff_T *dp; | |
2671 diff_T *dprev; | |
2672 diff_T *dfree; | |
2673 int idx_cur; | |
2674 int idx_other; | |
2675 int idx_from; | |
2676 int idx_to; | |
2677 int i; | |
2678 int added; | |
2679 char_u *p; | |
2680 aco_save_T aco; | |
2681 buf_T *buf; | |
2682 int start_skip, end_skip; | |
2683 int new_count; | |
648 | 2684 int buf_empty; |
1075 | 2685 int found_not_ma = FALSE; |
7 | 2686 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2687 // Find the current buffer in the list of diff buffers. |
7 | 2688 idx_cur = diff_buf_idx(curbuf); |
2689 if (idx_cur == DB_COUNT) | |
2690 { | |
26602
fac6673086df
patch 8.2.3830: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26044
diff
changeset
|
2691 emsg(_(e_current_buffer_is_not_in_diff_mode)); |
7 | 2692 return; |
2693 } | |
2694 | |
2695 if (*eap->arg == NUL) | |
2696 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2697 // No argument: Find the other buffer in the list of diff buffers. |
7 | 2698 for (idx_other = 0; idx_other < DB_COUNT; ++idx_other) |
672 | 2699 if (curtab->tp_diffbuf[idx_other] != curbuf |
1075 | 2700 && curtab->tp_diffbuf[idx_other] != NULL) |
2701 { | |
2702 if (eap->cmdidx != CMD_diffput | |
2703 || curtab->tp_diffbuf[idx_other]->b_p_ma) | |
2704 break; | |
2705 found_not_ma = TRUE; | |
2706 } | |
7 | 2707 if (idx_other == DB_COUNT) |
2708 { | |
1075 | 2709 if (found_not_ma) |
26958
d92e0d85923f
patch 8.2.4008: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26877
diff
changeset
|
2710 emsg(_(e_no_other_buffer_in_diff_mode_is_modifiable)); |
1075 | 2711 else |
26602
fac6673086df
patch 8.2.3830: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26044
diff
changeset
|
2712 emsg(_(e_no_other_buffer_in_diff_mode)); |
7 | 2713 return; |
2714 } | |
2715 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2716 // Check that there isn't a third buffer in the list |
7 | 2717 for (i = idx_other + 1; i < DB_COUNT; ++i) |
672 | 2718 if (curtab->tp_diffbuf[i] != curbuf |
2719 && curtab->tp_diffbuf[i] != NULL | |
2720 && (eap->cmdidx != CMD_diffput || curtab->tp_diffbuf[i]->b_p_ma)) | |
7 | 2721 { |
26602
fac6673086df
patch 8.2.3830: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26044
diff
changeset
|
2722 emsg(_(e_more_than_two_buffers_in_diff_mode_dont_know_which_one_to_use)); |
7 | 2723 return; |
2724 } | |
2725 } | |
2726 else | |
2727 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2728 // Buffer number or pattern given. Ignore trailing white space. |
7 | 2729 p = eap->arg + STRLEN(eap->arg); |
11129
f4ea50924c6d
patch 8.0.0452: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11121
diff
changeset
|
2730 while (p > eap->arg && VIM_ISWHITE(p[-1])) |
7 | 2731 --p; |
2732 for (i = 0; vim_isdigit(eap->arg[i]) && eap->arg + i < p; ++i) | |
2733 ; | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2734 if (eap->arg + i == p) // digits only |
7 | 2735 i = atol((char *)eap->arg); |
2736 else | |
2737 { | |
4236 | 2738 i = buflist_findpat(eap->arg, p, FALSE, TRUE, FALSE); |
7 | 2739 if (i < 0) |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2740 return; // error message already given |
7 | 2741 } |
2742 buf = buflist_findnr(i); | |
2743 if (buf == NULL) | |
2744 { | |
26602
fac6673086df
patch 8.2.3830: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26044
diff
changeset
|
2745 semsg(_(e_cant_find_buffer_str), eap->arg); |
7 | 2746 return; |
2747 } | |
1788 | 2748 if (buf == curbuf) |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2749 return; // nothing to do |
7 | 2750 idx_other = diff_buf_idx(buf); |
2751 if (idx_other == DB_COUNT) | |
2752 { | |
26602
fac6673086df
patch 8.2.3830: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26044
diff
changeset
|
2753 semsg(_(e_buffer_str_is_not_in_diff_mode), eap->arg); |
7 | 2754 return; |
2755 } | |
2756 } | |
2757 | |
2758 diff_busy = TRUE; | |
2759 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2760 // When no range given include the line above or below the cursor. |
7 | 2761 if (eap->addr_count == 0) |
2762 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2763 // Make it possible that ":diffget" on the last line gets line below |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2764 // the cursor line when there is no difference above the cursor. |
7 | 2765 if (eap->cmdidx == CMD_diffget |
2766 && eap->line1 == curbuf->b_ml.ml_line_count | |
2767 && diff_check(curwin, eap->line1) == 0 | |
2768 && (eap->line1 == 1 || diff_check(curwin, eap->line1 - 1) == 0)) | |
2769 ++eap->line2; | |
2770 else if (eap->line1 > 0) | |
2771 --eap->line1; | |
2772 } | |
2773 | |
2774 if (eap->cmdidx == CMD_diffget) | |
2775 { | |
2776 idx_from = idx_other; | |
2777 idx_to = idx_cur; | |
2778 } | |
2779 else | |
2780 { | |
2781 idx_from = idx_cur; | |
2782 idx_to = idx_other; | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2783 // Need to make the other buffer the current buffer to be able to make |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2784 // changes in it. |
31263
d8e7d725a666
patch 9.0.0965: using one window for executing autocommands is insufficient
Bram Moolenaar <Bram@vim.org>
parents:
29732
diff
changeset
|
2785 // Set curwin/curbuf to buf and save a few things. |
672 | 2786 aucmd_prepbuf(&aco, curtab->tp_diffbuf[idx_other]); |
31263
d8e7d725a666
patch 9.0.0965: using one window for executing autocommands is insufficient
Bram Moolenaar <Bram@vim.org>
parents:
29732
diff
changeset
|
2787 if (curbuf != curtab->tp_diffbuf[idx_other]) |
d8e7d725a666
patch 9.0.0965: using one window for executing autocommands is insufficient
Bram Moolenaar <Bram@vim.org>
parents:
29732
diff
changeset
|
2788 // Could not find a window for this buffer, the rest is likely to |
d8e7d725a666
patch 9.0.0965: using one window for executing autocommands is insufficient
Bram Moolenaar <Bram@vim.org>
parents:
29732
diff
changeset
|
2789 // fail. |
d8e7d725a666
patch 9.0.0965: using one window for executing autocommands is insufficient
Bram Moolenaar <Bram@vim.org>
parents:
29732
diff
changeset
|
2790 goto theend; |
7 | 2791 } |
2792 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2793 // May give the warning for a changed buffer here, which can trigger the |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2794 // FileChangedRO autocommand, which may do nasty things and mess |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2795 // everything up. |
819 | 2796 if (!curbuf->b_changed) |
2797 { | |
2798 change_warning(0); | |
2799 if (diff_buf_idx(curbuf) != idx_to) | |
2800 { | |
26958
d92e0d85923f
patch 8.2.4008: error messages are spread out
Bram Moolenaar <Bram@vim.org>
parents:
26877
diff
changeset
|
2801 emsg(_(e_buffer_changed_unexpectedly)); |
14776
09c1f241e2f7
patch 8.1.0400: using freed memory with :diffget
Christian Brabandt <cb@256bit.org>
parents:
14770
diff
changeset
|
2802 goto theend; |
819 | 2803 } |
2804 } | |
2805 | |
7 | 2806 dprev = NULL; |
672 | 2807 for (dp = curtab->tp_first_diff; dp != NULL; ) |
7 | 2808 { |
2809 if (dp->df_lnum[idx_cur] > eap->line2 + off) | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2810 break; // past the range that was specified |
7 | 2811 |
2812 dfree = NULL; | |
2813 lnum = dp->df_lnum[idx_to]; | |
2814 count = dp->df_count[idx_to]; | |
2815 if (dp->df_lnum[idx_cur] + dp->df_count[idx_cur] > eap->line1 + off | |
2816 && u_save(lnum - 1, lnum + count) != FAIL) | |
2817 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2818 // Inside the specified range and saving for undo worked. |
7 | 2819 start_skip = 0; |
2820 end_skip = 0; | |
2821 if (eap->addr_count > 0) | |
2822 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2823 // A range was specified: check if lines need to be skipped. |
7 | 2824 start_skip = eap->line1 + off - dp->df_lnum[idx_cur]; |
2825 if (start_skip > 0) | |
2826 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2827 // range starts below start of current diff block |
7 | 2828 if (start_skip > count) |
2829 { | |
2830 lnum += count; | |
2831 count = 0; | |
2832 } | |
2833 else | |
2834 { | |
2835 count -= start_skip; | |
2836 lnum += start_skip; | |
2837 } | |
2838 } | |
2839 else | |
2840 start_skip = 0; | |
2841 | |
2842 end_skip = dp->df_lnum[idx_cur] + dp->df_count[idx_cur] - 1 | |
2843 - (eap->line2 + off); | |
2844 if (end_skip > 0) | |
2845 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2846 // range ends above end of current/from diff block |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2847 if (idx_cur == idx_from) // :diffput |
7 | 2848 { |
2849 i = dp->df_count[idx_cur] - start_skip - end_skip; | |
2850 if (count > i) | |
2851 count = i; | |
2852 } | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2853 else // :diffget |
7 | 2854 { |
2855 count -= end_skip; | |
2856 end_skip = dp->df_count[idx_from] - start_skip - count; | |
2857 if (end_skip < 0) | |
2858 end_skip = 0; | |
2859 } | |
2860 } | |
2861 else | |
2862 end_skip = 0; | |
2863 } | |
2864 | |
11121
778c10516955
patch 8.0.0448: some macros are in lower case
Christian Brabandt <cb@256bit.org>
parents:
11113
diff
changeset
|
2865 buf_empty = BUFEMPTY(); |
7 | 2866 added = 0; |
2867 for (i = 0; i < count; ++i) | |
2868 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2869 // remember deleting the last line of the buffer |
648 | 2870 buf_empty = curbuf->b_ml.ml_line_count == 1; |
29519
3afe997f4415
patch 9.0.0101: invalid memory access in diff mode with "dp" and undo
Bram Moolenaar <Bram@vim.org>
parents:
29367
diff
changeset
|
2871 if (ml_delete(lnum) == OK) |
3afe997f4415
patch 9.0.0101: invalid memory access in diff mode with "dp" and undo
Bram Moolenaar <Bram@vim.org>
parents:
29367
diff
changeset
|
2872 --added; |
7 | 2873 } |
2874 for (i = 0; i < dp->df_count[idx_from] - start_skip - end_skip; ++i) | |
2875 { | |
2876 linenr_T nr; | |
2877 | |
2878 nr = dp->df_lnum[idx_from] + start_skip + i; | |
672 | 2879 if (nr > curtab->tp_diffbuf[idx_from]->b_ml.ml_line_count) |
7 | 2880 break; |
819 | 2881 p = vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx_from], |
2882 nr, FALSE)); | |
7 | 2883 if (p != NULL) |
2884 { | |
2885 ml_append(lnum + i - 1, p, 0, FALSE); | |
2886 vim_free(p); | |
2887 ++added; | |
648 | 2888 if (buf_empty && curbuf->b_ml.ml_line_count == 2) |
2889 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2890 // Added the first line into an empty buffer, need to |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2891 // delete the dummy empty line. |
648 | 2892 buf_empty = FALSE; |
20599
d571231175b4
patch 8.2.0853: ml_delete() often called with FALSE argument
Bram Moolenaar <Bram@vim.org>
parents:
20007
diff
changeset
|
2893 ml_delete((linenr_T)2); |
648 | 2894 } |
7 | 2895 } |
2896 } | |
2897 new_count = dp->df_count[idx_to] + added; | |
2898 dp->df_count[idx_to] = new_count; | |
2899 | |
2900 if (start_skip == 0 && end_skip == 0) | |
2901 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2902 // Check if there are any other buffers and if the diff is |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2903 // equal in them. |
7 | 2904 for (i = 0; i < DB_COUNT; ++i) |
819 | 2905 if (curtab->tp_diffbuf[i] != NULL && i != idx_from |
2906 && i != idx_to | |
7 | 2907 && !diff_equal_entry(dp, idx_from, i)) |
2908 break; | |
2909 if (i == DB_COUNT) | |
2910 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2911 // delete the diff entry, the buffers are now equal here |
7 | 2912 dfree = dp; |
2913 dp = dp->df_next; | |
2914 if (dprev == NULL) | |
672 | 2915 curtab->tp_first_diff = dp; |
7 | 2916 else |
2917 dprev->df_next = dp; | |
2918 } | |
2919 } | |
2920 | |
2921 if (added != 0) | |
2922 { | |
29367
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2923 // Adjust marks. This will change the following entries! |
7 | 2924 mark_adjust(lnum, lnum + count - 1, (long)MAXLNUM, (long)added); |
2925 if (curwin->w_cursor.lnum >= lnum) | |
2926 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2927 // Adjust the cursor position if it's in/after the changed |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2928 // lines. |
7 | 2929 if (curwin->w_cursor.lnum >= lnum + count) |
2930 curwin->w_cursor.lnum += added; | |
2931 else if (added < 0) | |
2932 curwin->w_cursor.lnum = lnum; | |
2933 } | |
2934 } | |
2935 changed_lines(lnum, 0, lnum + count, (long)added); | |
2936 | |
2937 if (dfree != NULL) | |
2938 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2939 // Diff is deleted, update folds in other windows. |
7 | 2940 #ifdef FEAT_FOLDING |
2941 diff_fold_update(dfree, idx_to); | |
2942 #endif | |
2943 vim_free(dfree); | |
2944 } | |
29367
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2945 |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2946 // mark_adjust() may have made "dp" invalid. We don't know where |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2947 // to continue then, bail out. |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2948 if (added != 0 && !valid_diff(dp)) |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2949 break; |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2950 |
cc4b36422ecb
patch 9.0.0026: accessing freed memory with diff put
Bram Moolenaar <Bram@vim.org>
parents:
29295
diff
changeset
|
2951 if (dfree == NULL) |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2952 // mark_adjust() may have changed the count in a wrong way |
7 | 2953 dp->df_count[idx_to] = new_count; |
2954 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2955 // When changing the current buffer, keep track of line numbers |
7 | 2956 if (idx_cur == idx_to) |
2957 off += added; | |
2958 } | |
2959 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2960 // If before the range or not deleted, go to next diff. |
7 | 2961 if (dfree == NULL) |
2962 { | |
2963 dprev = dp; | |
2964 dp = dp->df_next; | |
2965 } | |
2966 } | |
2967 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2968 // restore curwin/curbuf and a few other things |
2445
04dae202d316
Fixes for coverity warnings.
Bram Moolenaar <bram@vim.org>
parents:
2250
diff
changeset
|
2969 if (eap->cmdidx != CMD_diffget) |
7 | 2970 { |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2971 // Syncing undo only works for the current buffer, but we change |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2972 // another buffer. Sync undo if the command was typed. This isn't |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
2973 // 100% right when ":diffput" is used in a function or mapping. |
7 | 2974 if (KeyTyped) |
825 | 2975 u_sync(FALSE); |
7 | 2976 aucmd_restbuf(&aco); |
2977 } | |
2978 | |
14776
09c1f241e2f7
patch 8.1.0400: using freed memory with :diffget
Christian Brabandt <cb@256bit.org>
parents:
14770
diff
changeset
|
2979 theend: |
7 | 2980 diff_busy = FALSE; |
14776
09c1f241e2f7
patch 8.1.0400: using freed memory with :diffget
Christian Brabandt <cb@256bit.org>
parents:
14770
diff
changeset
|
2981 if (diff_need_update) |
14893
291656f731c9
patch 8.1.0458: ml_get error and crash when using "do"
Bram Moolenaar <Bram@vim.org>
parents:
14780
diff
changeset
|
2982 ex_diffupdate(NULL); |
291656f731c9
patch 8.1.0458: ml_get error and crash when using "do"
Bram Moolenaar <Bram@vim.org>
parents:
14780
diff
changeset
|
2983 |
14972
5d52b21b2e7f
patch 8.1.0497: :%diffput changes order of lines
Bram Moolenaar <Bram@vim.org>
parents:
14893
diff
changeset
|
2984 // Check that the cursor is on a valid character and update its |
14893
291656f731c9
patch 8.1.0458: ml_get error and crash when using "do"
Bram Moolenaar <Bram@vim.org>
parents:
14780
diff
changeset
|
2985 // position. When there were filler lines the topline has become |
291656f731c9
patch 8.1.0458: ml_get error and crash when using "do"
Bram Moolenaar <Bram@vim.org>
parents:
14780
diff
changeset
|
2986 // invalid. |
291656f731c9
patch 8.1.0458: ml_get error and crash when using "do"
Bram Moolenaar <Bram@vim.org>
parents:
14780
diff
changeset
|
2987 check_cursor(); |
291656f731c9
patch 8.1.0458: ml_get error and crash when using "do"
Bram Moolenaar <Bram@vim.org>
parents:
14780
diff
changeset
|
2988 changed_line_abv_curs(); |
291656f731c9
patch 8.1.0458: ml_get error and crash when using "do"
Bram Moolenaar <Bram@vim.org>
parents:
14780
diff
changeset
|
2989 |
291656f731c9
patch 8.1.0458: ml_get error and crash when using "do"
Bram Moolenaar <Bram@vim.org>
parents:
14780
diff
changeset
|
2990 if (diff_need_update) |
291656f731c9
patch 8.1.0458: ml_get error and crash when using "do"
Bram Moolenaar <Bram@vim.org>
parents:
14780
diff
changeset
|
2991 // redraw already done by ex_diffupdate() |
14776
09c1f241e2f7
patch 8.1.0400: using freed memory with :diffget
Christian Brabandt <cb@256bit.org>
parents:
14770
diff
changeset
|
2992 diff_need_update = FALSE; |
14780
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
2993 else |
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
2994 { |
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
2995 // Also need to redraw the other buffers. |
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
2996 diff_redraw(FALSE); |
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
2997 apply_autocmds(EVENT_DIFFUPDATED, NULL, NULL, FALSE, curbuf); |
552523e44923
patch 8.1.0402: the DiffUpdate event isn't triggered for :diffput
Christian Brabandt <cb@256bit.org>
parents:
14776
diff
changeset
|
2998 } |
7 | 2999 } |
3000 | |
3001 #ifdef FEAT_FOLDING | |
3002 /* | |
3003 * Update folds for all diff buffers for entry "dp". | |
3004 * Skip buffer with index "skip_idx". | |
3005 * When there are no diffs, all folds are removed. | |
3006 */ | |
3007 static void | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
3008 diff_fold_update(diff_T *dp, int skip_idx) |
7 | 3009 { |
3010 int i; | |
3011 win_T *wp; | |
3012 | |
9649
fd9727ae3c49
commit https://github.com/vim/vim/commit/2932359000b2f918d5fade79ea4d124d5943cd07
Christian Brabandt <cb@256bit.org>
parents:
9487
diff
changeset
|
3013 FOR_ALL_WINDOWS(wp) |
7 | 3014 for (i = 0; i < DB_COUNT; ++i) |
672 | 3015 if (curtab->tp_diffbuf[i] == wp->w_buffer && i != skip_idx) |
7 | 3016 foldUpdate(wp, dp->df_lnum[i], |
3017 dp->df_lnum[i] + dp->df_count[i]); | |
3018 } | |
3019 #endif | |
3020 | |
3021 /* | |
3022 * Return TRUE if buffer "buf" is in diff-mode. | |
3023 */ | |
3024 int | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
3025 diff_mode_buf(buf_T *buf) |
7 | 3026 { |
672 | 3027 tabpage_T *tp; |
3028 | |
9649
fd9727ae3c49
commit https://github.com/vim/vim/commit/2932359000b2f918d5fade79ea4d124d5943cd07
Christian Brabandt <cb@256bit.org>
parents:
9487
diff
changeset
|
3029 FOR_ALL_TABPAGES(tp) |
672 | 3030 if (diff_buf_idx_tp(buf, tp) != DB_COUNT) |
3031 return TRUE; | |
3032 return FALSE; | |
7 | 3033 } |
3034 | |
3035 /* | |
3036 * Move "count" times in direction "dir" to the next diff block. | |
3037 * Return FAIL if there isn't such a diff block. | |
3038 */ | |
3039 int | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
3040 diff_move_to(int dir, long count) |
7 | 3041 { |
3042 int idx; | |
3043 linenr_T lnum = curwin->w_cursor.lnum; | |
3044 diff_T *dp; | |
3045 | |
3046 idx = diff_buf_idx(curbuf); | |
672 | 3047 if (idx == DB_COUNT || curtab->tp_first_diff == NULL) |
7 | 3048 return FAIL; |
3049 | |
672 | 3050 if (curtab->tp_diff_invalid) |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3051 ex_diffupdate(NULL); // update after a big change |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3052 |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3053 if (curtab->tp_first_diff == NULL) // no diffs today |
7 | 3054 return FAIL; |
3055 | |
3056 while (--count >= 0) | |
3057 { | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3058 // Check if already before first diff. |
672 | 3059 if (dir == BACKWARD && lnum <= curtab->tp_first_diff->df_lnum[idx]) |
7 | 3060 break; |
3061 | |
672 | 3062 for (dp = curtab->tp_first_diff; ; dp = dp->df_next) |
7 | 3063 { |
3064 if (dp == NULL) | |
3065 break; | |
3066 if ((dir == FORWARD && lnum < dp->df_lnum[idx]) | |
3067 || (dir == BACKWARD | |
3068 && (dp->df_next == NULL | |
3069 || lnum <= dp->df_next->df_lnum[idx]))) | |
3070 { | |
3071 lnum = dp->df_lnum[idx]; | |
3072 break; | |
3073 } | |
3074 } | |
3075 } | |
3076 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3077 // don't end up past the end of the file |
7 | 3078 if (lnum > curbuf->b_ml.ml_line_count) |
3079 lnum = curbuf->b_ml.ml_line_count; | |
3080 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3081 // When the cursor didn't move at all we fail. |
7 | 3082 if (lnum == curwin->w_cursor.lnum) |
3083 return FAIL; | |
3084 | |
3085 setpcmark(); | |
3086 curwin->w_cursor.lnum = lnum; | |
3087 curwin->w_cursor.col = 0; | |
3088 | |
3089 return OK; | |
3090 } | |
3091 | |
10295
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3092 /* |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3093 * Return the line number in the current window that is closest to "lnum1" in |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3094 * "buf1" in diff mode. |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3095 */ |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3096 static linenr_T |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3097 diff_get_corresponding_line_int( |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
3098 buf_T *buf1, |
10295
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3099 linenr_T lnum1) |
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3100 { |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3101 int idx1; |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3102 int idx2; |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3103 diff_T *dp; |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3104 int baseline = 0; |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3105 |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3106 idx1 = diff_buf_idx(buf1); |
10295
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3107 idx2 = diff_buf_idx(curbuf); |
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3108 if (idx1 == DB_COUNT || idx2 == DB_COUNT || curtab->tp_first_diff == NULL) |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3109 return lnum1; |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3110 |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3111 if (curtab->tp_diff_invalid) |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3112 ex_diffupdate(NULL); // update after a big change |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3113 |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3114 if (curtab->tp_first_diff == NULL) // no diffs today |
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3115 return lnum1; |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3116 |
19888
435726a03481
patch 8.2.0500: using the same loop in many places
Bram Moolenaar <Bram@vim.org>
parents:
18777
diff
changeset
|
3117 FOR_ALL_DIFFBLOCKS_IN_TAB(curtab, dp) |
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3118 { |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3119 if (dp->df_lnum[idx1] > lnum1) |
10295
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3120 return lnum1 - baseline; |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3121 if ((dp->df_lnum[idx1] + dp->df_count[idx1]) > lnum1) |
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3122 { |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3123 // Inside the diffblock |
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3124 baseline = lnum1 - dp->df_lnum[idx1]; |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3125 if (baseline > dp->df_count[idx2]) |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3126 baseline = dp->df_count[idx2]; |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3127 |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3128 return dp->df_lnum[idx2] + baseline; |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3129 } |
10295
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3130 if ( (dp->df_lnum[idx1] == lnum1) |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3131 && (dp->df_count[idx1] == 0) |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3132 && (dp->df_lnum[idx2] <= curwin->w_cursor.lnum) |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3133 && ((dp->df_lnum[idx2] + dp->df_count[idx2]) |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3134 > curwin->w_cursor.lnum)) |
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3135 /* |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3136 * Special case: if the cursor is just after a zero-count |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3137 * block (i.e. all filler) and the target cursor is already |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3138 * inside the corresponding block, leave the target cursor |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3139 * unmoved. This makes repeated CTRL-W W operations work |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3140 * as expected. |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3141 */ |
10295
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3142 return curwin->w_cursor.lnum; |
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3143 baseline = (dp->df_lnum[idx1] + dp->df_count[idx1]) |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3144 - (dp->df_lnum[idx2] + dp->df_count[idx2]); |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3145 } |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3146 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3147 // If we get here then the cursor is after the last diff |
10295
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3148 return lnum1 - baseline; |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3149 } |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3150 |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3151 /* |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3152 * Return the line number in the current window that is closest to "lnum1" in |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3153 * "buf1" in diff mode. Checks the line number to be valid. |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3154 */ |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3155 linenr_T |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3156 diff_get_corresponding_line(buf_T *buf1, linenr_T lnum1) |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3157 { |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3158 linenr_T lnum = diff_get_corresponding_line_int(buf1, lnum1); |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3159 |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3160 // don't end up past the end of the file |
10295
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3161 if (lnum > curbuf->b_ml.ml_line_count) |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3162 return curbuf->b_ml.ml_line_count; |
d0b74b18e4b5
commit https://github.com/vim/vim/commit/025e3e0bafbc85cc4e365145af711edf99d0a90d
Christian Brabandt <cb@256bit.org>
parents:
10042
diff
changeset
|
3163 return lnum; |
2250
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3164 } |
1bac28a53fae
Add the conceal patch from Vince Negri.
Bram Moolenaar <bram@vim.org>
parents:
2086
diff
changeset
|
3165 |
7 | 3166 /* |
3167 * For line "lnum" in the current window find the equivalent lnum in window | |
3168 * "wp", compensating for inserted/deleted lines. | |
3169 */ | |
3170 linenr_T | |
7817
83861277e6a3
commit https://github.com/vim/vim/commit/7454a06e2642d2b37afad1c5e71cec68081ca4ff
Christian Brabandt <cb@256bit.org>
parents:
7799
diff
changeset
|
3171 diff_lnum_win(linenr_T lnum, win_T *wp) |
7 | 3172 { |
3173 diff_T *dp; | |
3174 int idx; | |
3175 int i; | |
3176 linenr_T n; | |
3177 | |
3178 idx = diff_buf_idx(curbuf); | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3179 if (idx == DB_COUNT) // safety check |
7 | 3180 return (linenr_T)0; |
3181 | |
672 | 3182 if (curtab->tp_diff_invalid) |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3183 ex_diffupdate(NULL); // update after a big change |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3184 |
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3185 // search for a change that includes "lnum" in the list of diffblocks. |
19888
435726a03481
patch 8.2.0500: using the same loop in many places
Bram Moolenaar <Bram@vim.org>
parents:
18777
diff
changeset
|
3186 FOR_ALL_DIFFBLOCKS_IN_TAB(curtab, dp) |
7 | 3187 if (lnum <= dp->df_lnum[idx] + dp->df_count[idx]) |
3188 break; | |
3189 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3190 // When after the last change, compute relative to the last line number. |
7 | 3191 if (dp == NULL) |
3192 return wp->w_buffer->b_ml.ml_line_count | |
3193 - (curbuf->b_ml.ml_line_count - lnum); | |
3194 | |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3195 // Find index for "wp". |
7 | 3196 i = diff_buf_idx(wp->w_buffer); |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3197 if (i == DB_COUNT) // safety check |
7 | 3198 return (linenr_T)0; |
3199 | |
3200 n = lnum + (dp->df_lnum[i] - dp->df_lnum[idx]); | |
3201 if (n > dp->df_lnum[i] + dp->df_count[i]) | |
3202 n = dp->df_lnum[i] + dp->df_count[i]; | |
3203 return n; | |
3204 } | |
3205 | |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3206 /* |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3207 * Handle an ED style diff line. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3208 * Return FAIL if the line does not contain diff info. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3209 */ |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3210 static int |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3211 parse_diff_ed( |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3212 char_u *line, |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3213 diffhunk_T *hunk) |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3214 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3215 char_u *p; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3216 long f1, l1, f2, l2; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3217 int difftype; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3218 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3219 // The line must be one of three formats: |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3220 // change: {first}[,{last}]c{first}[,{last}] |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3221 // append: {first}a{first}[,{last}] |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3222 // delete: {first}[,{last}]d{first} |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3223 p = line; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3224 f1 = getdigits(&p); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3225 if (*p == ',') |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3226 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3227 ++p; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3228 l1 = getdigits(&p); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3229 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3230 else |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3231 l1 = f1; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3232 if (*p != 'a' && *p != 'c' && *p != 'd') |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3233 return FAIL; // invalid diff format |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3234 difftype = *p++; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3235 f2 = getdigits(&p); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3236 if (*p == ',') |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3237 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3238 ++p; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3239 l2 = getdigits(&p); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3240 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3241 else |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3242 l2 = f2; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3243 if (l1 < f1 || l2 < f2) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3244 return FAIL; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3245 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3246 if (difftype == 'a') |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3247 { |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3248 hunk->lnum_orig = f1 + 1; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3249 hunk->count_orig = 0; |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3250 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3251 else |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3252 { |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3253 hunk->lnum_orig = f1; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3254 hunk->count_orig = l1 - f1 + 1; |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3255 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3256 if (difftype == 'd') |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3257 { |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3258 hunk->lnum_new = f2 + 1; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3259 hunk->count_new = 0; |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3260 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3261 else |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3262 { |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3263 hunk->lnum_new = f2; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3264 hunk->count_new = l2 - f2 + 1; |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3265 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3266 return OK; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3267 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3268 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3269 /* |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3270 * Parses unified diff with zero(!) context lines. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3271 * Return FAIL if there is no diff information in "line". |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3272 */ |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3273 static int |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3274 parse_diff_unified( |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3275 char_u *line, |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3276 diffhunk_T *hunk) |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3277 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3278 char_u *p; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3279 long oldline, oldcount, newline, newcount; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3280 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3281 // Parse unified diff hunk header: |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3282 // @@ -oldline,oldcount +newline,newcount @@ |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3283 p = line; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3284 if (*p++ == '@' && *p++ == '@' && *p++ == ' ' && *p++ == '-') |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3285 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3286 oldline = getdigits(&p); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3287 if (*p == ',') |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3288 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3289 ++p; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3290 oldcount = getdigits(&p); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3291 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3292 else |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3293 oldcount = 1; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3294 if (*p++ == ' ' && *p++ == '+') |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3295 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3296 newline = getdigits(&p); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3297 if (*p == ',') |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3298 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3299 ++p; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3300 newcount = getdigits(&p); |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3301 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3302 else |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3303 newcount = 1; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3304 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3305 else |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3306 return FAIL; // invalid diff format |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3307 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3308 if (oldcount == 0) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3309 oldline += 1; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3310 if (newcount == 0) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3311 newline += 1; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3312 if (newline == 0) |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3313 newline = 1; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3314 |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3315 hunk->lnum_orig = oldline; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3316 hunk->count_orig = oldcount; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3317 hunk->lnum_new = newline; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3318 hunk->count_new = newcount; |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3319 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3320 return OK; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3321 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3322 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3323 return FAIL; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3324 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3325 |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3326 /* |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3327 * Callback function for the xdl_diff() function. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3328 * Stores the diff output in a grow array. |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3329 */ |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3330 static int |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3331 xdiff_out( |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3332 long start_a, |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3333 long count_a, |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3334 long start_b, |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3335 long count_b, |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3336 void *priv) |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3337 { |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3338 diffout_T *dout = (diffout_T *)priv; |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3339 diffhunk_T *p = ALLOC_ONE(diffhunk_T); |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3340 |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3341 if (p == NULL) |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3342 return -1; |
14982
d56f14540dda
patch 8.1.0502: internal diff fails when diffing a context diff
Bram Moolenaar <Bram@vim.org>
parents:
14972
diff
changeset
|
3343 |
d56f14540dda
patch 8.1.0502: internal diff fails when diffing a context diff
Bram Moolenaar <Bram@vim.org>
parents:
14972
diff
changeset
|
3344 if (ga_grow(&dout->dout_ga, 1) == FAIL) |
26805
77ff030699d2
patch 8.2.3931: Coverity reports a memory leak
Bram Moolenaar <Bram@vim.org>
parents:
26794
diff
changeset
|
3345 { |
77ff030699d2
patch 8.2.3931: Coverity reports a memory leak
Bram Moolenaar <Bram@vim.org>
parents:
26794
diff
changeset
|
3346 vim_free(p); |
14982
d56f14540dda
patch 8.1.0502: internal diff fails when diffing a context diff
Bram Moolenaar <Bram@vim.org>
parents:
14972
diff
changeset
|
3347 return -1; |
26805
77ff030699d2
patch 8.2.3931: Coverity reports a memory leak
Bram Moolenaar <Bram@vim.org>
parents:
26794
diff
changeset
|
3348 } |
26786
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3349 |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3350 p->lnum_orig = start_a + 1; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3351 p->count_orig = count_a; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3352 p->lnum_new = start_b + 1; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3353 p->count_new = count_b; |
b802798e4a26
patch 8.2.3921: the way xdiff is used is inefficient
Bram Moolenaar <Bram@vim.org>
parents:
26771
diff
changeset
|
3354 ((diffhunk_T **)dout->dout_ga.ga_data)[dout->dout_ga.ga_len++] = p; |
14696
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3355 return 0; |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3356 } |
195e8b1fcbbf
patch 8.1.0360: using an external diff program is slow and inflexible
Christian Brabandt <cb@256bit.org>
parents:
14019
diff
changeset
|
3357 |
17986
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3358 #endif // FEAT_DIFF |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3359 |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3360 #if defined(FEAT_EVAL) || defined(PROTO) |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3361 |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3362 /* |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3363 * "diff_filler()" function |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3364 */ |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3365 void |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3366 f_diff_filler(typval_T *argvars UNUSED, typval_T *rettv UNUSED) |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3367 { |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3368 #ifdef FEAT_DIFF |
25384
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25314
diff
changeset
|
3369 if (in_vim9script() && check_for_lnum_arg(argvars, 0) == FAIL) |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25314
diff
changeset
|
3370 return; |
e8e2c4d33b9b
patch 8.2.3229: Vim9: runtime and compile time type checks are not the same
Bram Moolenaar <Bram@vim.org>
parents:
25314
diff
changeset
|
3371 |
17986
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3372 rettv->vval.v_number = diff_check_fill(curwin, tv_get_lnum(argvars)); |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3373 #endif |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3374 } |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3375 |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3376 /* |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3377 * "diff_hlID()" function |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3378 */ |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3379 void |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3380 f_diff_hlID(typval_T *argvars UNUSED, typval_T *rettv UNUSED) |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3381 { |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3382 #ifdef FEAT_DIFF |
25272
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
24683
diff
changeset
|
3383 linenr_T lnum; |
17986
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3384 static linenr_T prev_lnum = 0; |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3385 static varnumber_T changedtick = 0; |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3386 static int fnum = 0; |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3387 static int change_start = 0; |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3388 static int change_end = 0; |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3389 static hlf_T hlID = (hlf_T)0; |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3390 int filler_lines; |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3391 int col; |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3392 |
25272
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
24683
diff
changeset
|
3393 if (in_vim9script() |
25314
7e620652bd13
patch 8.2.3194: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
25302
diff
changeset
|
3394 && (check_for_lnum_arg(argvars,0) == FAIL |
25272
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
24683
diff
changeset
|
3395 || check_for_number_arg(argvars, 1) == FAIL)) |
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
24683
diff
changeset
|
3396 return; |
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
24683
diff
changeset
|
3397 |
712e867f9721
patch 8.2.3173: Vim9: argument types are not checked at compile time
Bram Moolenaar <Bram@vim.org>
parents:
24683
diff
changeset
|
3398 lnum = tv_get_lnum(argvars); |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3399 if (lnum < 0) // ignore type error in {lnum} arg |
17986
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3400 lnum = 0; |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3401 if (lnum != prev_lnum |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3402 || changedtick != CHANGEDTICK(curbuf) |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3403 || fnum != curbuf->b_fnum) |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3404 { |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3405 // New line, buffer, change: need to get the values. |
17986
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3406 filler_lines = diff_check(curwin, lnum); |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3407 if (filler_lines < 0) |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3408 { |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3409 if (filler_lines == -1) |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3410 { |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3411 change_start = MAXCOL; |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3412 change_end = -1; |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3413 if (diff_find_change(curwin, lnum, &change_start, &change_end)) |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3414 hlID = HLF_ADD; // added line |
17986
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3415 else |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3416 hlID = HLF_CHD; // changed line |
17986
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3417 } |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3418 else |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3419 hlID = HLF_ADD; // added line |
17986
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3420 } |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3421 else |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3422 hlID = (hlf_T)0; |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3423 prev_lnum = lnum; |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3424 changedtick = CHANGEDTICK(curbuf); |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3425 fnum = curbuf->b_fnum; |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3426 } |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3427 |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3428 if (hlID == HLF_CHD || hlID == HLF_TXD) |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3429 { |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3430 col = tv_get_number(&argvars[1]) - 1; // ignore type error in {col} |
17986
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3431 if (col >= change_start && col <= change_end) |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3432 hlID = HLF_TXD; // changed text |
17986
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3433 else |
18777
3a68dc2a1bc1
patch 8.1.2378: using old C style comments
Bram Moolenaar <Bram@vim.org>
parents:
18619
diff
changeset
|
3434 hlID = HLF_CHD; // changed line |
17986
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3435 } |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3436 rettv->vval.v_number = hlID == (hlf_T)0 ? 0 : (int)hlID; |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3437 #endif |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3438 } |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3439 |
5c8906f653f5
patch 8.1.1989: the evalfunc.c file is still too big
Bram Moolenaar <Bram@vim.org>
parents:
17851
diff
changeset
|
3440 #endif |