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