diff options
Diffstat (limited to 'data/vim/patches/8.1.0360')
| -rw-r--r-- | data/vim/patches/8.1.0360 | 6803 |
1 files changed, 6803 insertions, 0 deletions
diff --git a/data/vim/patches/8.1.0360 b/data/vim/patches/8.1.0360 new file mode 100644 index 000000000..df0fd10d6 --- /dev/null +++ b/data/vim/patches/8.1.0360 @@ -0,0 +1,6803 @@ +To: vim_dev@googlegroups.com +Subject: Patch 8.1.0360 +Fcc: outbox +From: Bram Moolenaar <Bram@moolenaar.net> +Mime-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit +------------ + +Patch 8.1.0360 +Problem: Using an external diff program is slow and inflexible. +Solution: Include the xdiff library. (Christian Brabandt, closes #2732) + Use it by default. +Files: Filelist, runtime/doc/diff.txt, runtime/doc/options.txt, + src/Make_cyg_ming.mak, src/Make_mvc.mak, src/Makefile, src/diff.c, + src/structs.h, src/testdir/dumps/Test_diff_01.dump, + src/testdir/dumps/Test_diff_02.dump, + src/testdir/dumps/Test_diff_03.dump, + src/testdir/dumps/Test_diff_04.dump, + src/testdir/dumps/Test_diff_05.dump, + src/testdir/dumps/Test_diff_06.dump, + src/testdir/dumps/Test_diff_07.dump, + src/testdir/dumps/Test_diff_08.dump, + src/testdir/dumps/Test_diff_09.dump, + src/testdir/dumps/Test_diff_10.dump, + src/testdir/dumps/Test_diff_11.dump, + src/testdir/dumps/Test_diff_12.dump, + src/testdir/dumps/Test_diff_13.dump, + src/testdir/dumps/Test_diff_14.dump, + src/testdir/dumps/Test_diff_15.dump, + src/testdir/dumps/Test_diff_16.dump, + src/testdir/test_diffmode.vim, src/xdiff/COPYING, + src/xdiff/xdiff.h, src/xdiff/xdiffi.c, src/xdiff/xdiffi.h, + src/xdiff/xemit.c, src/xdiff/xemit.h, src/xdiff/xhistogram.c, + src/xdiff/xinclude.h, src/xdiff/xmacros.h, src/xdiff/xpatience.c, + src/xdiff/xprepare.c, src/xdiff/xprepare.h, src/xdiff/xtypes.h, + src/xdiff/xutils.c, src/xdiff/xutils.h, src/xdiff/README.txt + + +*** ../vim-8.1.0359/Filelist 2018-09-02 15:26:53.829022193 +0200 +--- Filelist 2018-09-10 17:23:29.323602967 +0200 +*************** +*** 273,278 **** +--- 273,292 ---- + src/libvterm/t/92lp1640917.test \ + src/libvterm/t/harness.c \ + src/libvterm/t/run-test.pl \ ++ src/xdiff/xdiff.h \ ++ src/xdiff/xdiffi.c \ ++ src/xdiff/xdiffi.h \ ++ src/xdiff/xemit.c \ ++ src/xdiff/xemit.h \ ++ src/xdiff/xhistogram.c \ ++ src/xdiff/xinclude.h \ ++ src/xdiff/xmacros.h \ ++ src/xdiff/xpatience.c \ ++ src/xdiff/xprepare.c \ ++ src/xdiff/xprepare.h \ ++ src/xdiff/xtypes.h \ ++ src/xdiff/xutils.c \ ++ src/xdiff/xutils.h \ + + + # source files for Unix only +*** ../vim-8.1.0359/runtime/doc/diff.txt 2018-05-17 13:40:51.000000000 +0200 +--- runtime/doc/diff.txt 2018-09-10 17:24:29.783082384 +0200 +*************** +*** 39,45 **** + then append the file name of the first argument to the directory name to find + the file. + +! This only works when a standard "diff" command is available. See 'diffexpr'. + + Diffs are local to the current tab page |tab-page|. You can't see diffs with + a window in another tab page. This does make it possible to have several +--- 39,47 ---- + then append the file name of the first argument to the directory name to find + the file. + +! By default an internal diff library will be used. When 'diffopt' or +! 'diffexpr' has been set an external "diff" command will be used. This only +! works when such a diff program is available. + + Diffs are local to the current tab page |tab-page|. You can't see diffs with + a window in another tab page. This does make it possible to have several +*************** +*** 344,351 **** + + The ">" is replaced with the value of 'shellredir'. + +! The output of "diff" must be a normal "ed" style diff. Do NOT use a context +! diff. This example explains the format that Vim expects: > + + 1a2 + > bbb +--- 346,354 ---- + + The ">" is replaced with the value of 'shellredir'. + +! The output of "diff" must be a normal "ed" style diff or a unified diff. Do +! NOT use a context diff. This example explains the format that Vim expects for +! the "ed" style diff: > + + 1a2 + > bbb +*************** +*** 384,395 **** +--- 387,402 ---- + endif + silent execute "!diff -a --binary " . opt . v:fname_in . " " . v:fname_new . + \ " > " . v:fname_out ++ redraw! + endfunction + + The "-a" argument is used to force comparing the files as text, comparing as + binaries isn't useful. The "--binary" argument makes the files read in binary + mode, so that a CTRL-Z doesn't end the text on DOS. + ++ The `redraw!` command may not be needed, depending on whether executing a ++ shell command shows something on the display or not. ++ + *E810* *E97* + Vim will do a test if the diff output looks alright. If it doesn't, you will + get an error message. Possible causes: +*************** +*** 441,444 **** + directory are accidentally patched. Vim will also delete files starting with + v:fname_in and ending in ".rej" and ".orig". + +! vim:tw=78:ts=8:ft=help:norl: +--- 448,451 ---- + directory are accidentally patched. Vim will also delete files starting with + v:fname_in and ending in ".rej" and ".orig". + +! vim:tw=78:ts=8:noet:ft=help:norl: +*** ../vim-8.1.0359/runtime/doc/options.txt 2018-08-07 21:39:09.243060141 +0200 +--- runtime/doc/options.txt 2018-09-10 17:25:45.414250299 +0200 +*************** +*** 2605,2612 **** + {not in Vi} + {not available when compiled without the |+diff| + feature} +! Expression which is evaluated to obtain an ed-style diff file from two +! versions of a file. See |diff-diffexpr|. + This option cannot be set from a |modeline| or in the |sandbox|, for + security reasons. + +--- 2609,2616 ---- + {not in Vi} + {not available when compiled without the |+diff| + feature} +! Expression which is evaluated to obtain a diff file (either ed-style +! or unified-style) from two versions of a file. See |diff-diffexpr|. + This option cannot be set from a |modeline| or in the |sandbox|, for + security reasons. + +*************** +*** 2653,2663 **** + foldcolumn:{n} Set the 'foldcolumn' option to {n} when + starting diff mode. Without this 2 is used. + +! Examples: > + +! :set diffopt=filler,context:4 + :set diffopt= +! :set diffopt=filler,foldcolumn:3 + < + *'digraph'* *'dg'* *'nodigraph'* *'nodg'* + 'digraph' 'dg' boolean (default off) +--- 2657,2687 ---- + foldcolumn:{n} Set the 'foldcolumn' option to {n} when + starting diff mode. Without this 2 is used. + +! internal Use the internal diff library. This is +! ignored when 'diffexpr' is set. *E960* +! When running out of memory when writing a +! buffer this item will be ignored for diffs +! involving that buffer. Set the 'verbose' +! option to see when this happens. +! +! indent-heuristic +! Use the indent heuristic for the internal +! diff library. +! +! algorithm:{text} Use the specified diff algorithm with the +! internal diff engine. Currently supported +! algorithms are: +! myers the default algorithm +! minimal spend extra time to generate the +! smallest possible diff +! patience patience diff algorithm +! histogram histogram diff algorithm + +! Examples: > +! :set diffopt=internal,filler,context:4 + :set diffopt= +! :set diffopt=internal,filler,foldcolumn:3 +! :set diffopt-=internal " do NOT use the internal diff parser + < + *'digraph'* *'dg'* *'nodigraph'* *'nodg'* + 'digraph' 'dg' boolean (default off) +*** ../vim-8.1.0359/src/Make_cyg_ming.mak 2018-06-30 16:25:00.551755794 +0200 +--- src/Make_cyg_ming.mak 2018-09-10 17:29:26.599063750 +0200 +*************** +*** 166,171 **** +--- 166,190 ---- + ifndef CROSS_COMPILE + CROSS_COMPILE = + endif ++ ++ # About the "sh.exe" condition, as explained by Ken Takata: ++ # ++ # If the makefile is executed with mingw32-make and sh.exe is not found in ++ # $PATH, then $SHELL is set to "sh.exe" (without any path). In this case, ++ # unix-like commands might not work and a dos-style path is needed. ++ # ++ # If the makefile is executed with mingw32-make and sh.exe IS found in $PATH, ++ # then $SHELL is set with the actual path of sh.exe (e.g. ++ # "C:/msys64/usr/bin/sh.exe"). In this case, unix-like commands can be used. ++ # ++ # If it is executed by the "make" command from cmd.exe, $SHELL is set to ++ # "/bin/sh". If the "make" command is in the $PATH, other unix-like commands ++ # might also work. ++ # ++ # If it is executed by the "make" command from a unix-like shell, ++ # $SHELL is set with the unix-style path (e.g. "/bin/bash"). ++ # In this case, unix-like commands can be used. ++ # + ifneq (sh.exe, $(SHELL)) + DEL = rm + MKDIR = mkdir -p +*************** +*** 810,815 **** +--- 829,851 ---- + $(OUTDIR)/term_vterm.o + endif + ++ # Include xdiff ++ OBJ += $(OUTDIR)/xdiffi.o \ ++ $(OUTDIR)/xemit.o \ ++ $(OUTDIR)/xprepare.o \ ++ $(OUTDIR)/xutils.o \ ++ $(OUTDIR)/xhistogram.o \ ++ $(OUTDIR)/xpatience.o ++ ++ XDIFF_DEPS = \ ++ xdiff/xdiff.h \ ++ xdiff/xdiffi.h \ ++ xdiff/xemit.h \ ++ xdiff/xinclude.h \ ++ xdiff/xmacros.h \ ++ xdiff/xprepare.h \ ++ xdiff/xtypes.h \ ++ xdiff/xutils.h + + ifdef MZSCHEME + MZSCHEME_SUFFIX = Z +*************** +*** 1055,1060 **** +--- 1091,1113 ---- + $(OUTDIR)/term_vterm.o: libvterm/src/vterm.c $(TERM_DEPS) + $(CCCTERM) libvterm/src/vterm.c -o $@ + ++ $(OUTDIR)/xdiffi.o: xdiff/xdiffi.c $(XDIFF_DEPS) ++ $(CC) -c $(CFLAGS) xdiff/xdiffi.c -o $(OUTDIR)/xdiffi.o ++ ++ $(OUTDIR)/xemit.o: xdiff/xemit.c $(XDIFF_DEPS) ++ $(CC) -c $(CFLAGS) xdiff/xemit.c -o $(OUTDIR)/xemit.o ++ ++ $(OUTDIR)/xprepare.o: xdiff/xprepare.c $(XDIFF_DEPS) ++ $(CC) -c $(CFLAGS) xdiff/xprepare.c -o $(OUTDIR)/xprepare.o ++ ++ $(OUTDIR)/xutils.o: xdiff/xutils.c $(XDIFF_DEPS) ++ $(CC) -c $(CFLAGS) xdiff/xutils.c -o $(OUTDIR)/xutils.o ++ ++ $(OUTDIR)/xhistogram.o: xdiff/xhistogram.c $(XDIFF_DEPS) ++ $(CC) -c $(CFLAGS) xdiff/xhistogram.c -o $(OUTDIR)/xhistogram.o ++ ++ $(OUTDIR)/xpatience.o: xdiff/xpatience.c $(XDIFF_DEPS) ++ $(CC) -c $(CFLAGS) xdiff/xpatience.c -o $(OUTDIR)/xpatience.o + + pathdef.c: $(INCL) + ifneq (sh.exe, $(SHELL)) +*** ../vim-8.1.0359/src/Make_mvc.mak 2018-07-04 23:05:19.221931527 +0200 +--- src/Make_mvc.mak 2018-09-10 17:32:03.885044447 +0200 +*************** +*** 813,818 **** +--- 813,836 ---- + !endif + SUBSYSTEM_TOOLS = console + ++ XDIFF_OBJ = $(OBJDIR)/xdiffi.obj \ ++ $(OBJDIR)/xemit.obj \ ++ $(OBJDIR)/xprepare.obj \ ++ $(OBJDIR)/xutils.obj \ ++ $(OBJDIR)/xhistogram.obj \ ++ $(OBJDIR)/xpatience.obj ++ ++ XDIFF_DEPS = \ ++ xdiff/xdiff.h \ ++ xdiff/xdiffi.h \ ++ xdiff/xemit.h \ ++ xdiff/xinclude.h \ ++ xdiff/xmacros.h \ ++ xdiff/xprepare.h \ ++ xdiff/xtypes.h \ ++ xdiff/xutils.h ++ ++ + !if "$(SUBSYSTEM_VER)" != "" + SUBSYSTEM = $(SUBSYSTEM),$(SUBSYSTEM_VER) + SUBSYSTEM_TOOLS = $(SUBSYSTEM_TOOLS),$(SUBSYSTEM_VER) +*************** +*** 1204,1215 **** + tee/tee.exe \ + GvimExt/gvimext.dll + +! $(VIM).exe: $(OUTDIR) $(OBJ) $(GUI_OBJ) $(CUI_OBJ) $(OLE_OBJ) $(OLE_IDL) $(MZSCHEME_OBJ) \ + $(LUA_OBJ) $(PERL_OBJ) $(PYTHON_OBJ) $(PYTHON3_OBJ) $(RUBY_OBJ) $(TCL_OBJ) \ + $(CSCOPE_OBJ) $(TERM_OBJ) $(NETBEANS_OBJ) $(CHANNEL_OBJ) $(XPM_OBJ) \ + version.c version.h + $(CC) $(CFLAGS_OUTDIR) version.c +! $(link) $(LINKARGS1) -out:$(VIM).exe $(OBJ) $(GUI_OBJ) $(CUI_OBJ) $(OLE_OBJ) \ + $(LUA_OBJ) $(MZSCHEME_OBJ) $(PERL_OBJ) $(PYTHON_OBJ) $(PYTHON3_OBJ) $(RUBY_OBJ) \ + $(TCL_OBJ) $(CSCOPE_OBJ) $(TERM_OBJ) $(NETBEANS_OBJ) $(CHANNEL_OBJ) \ + $(XPM_OBJ) $(OUTDIR)\version.obj $(LINKARGS2) +--- 1222,1233 ---- + tee/tee.exe \ + GvimExt/gvimext.dll + +! $(VIM).exe: $(OUTDIR) $(OBJ) $(XDIFF_OBJ) $(GUI_OBJ) $(CUI_OBJ) $(OLE_OBJ) $(OLE_IDL) $(MZSCHEME_OBJ) \ + $(LUA_OBJ) $(PERL_OBJ) $(PYTHON_OBJ) $(PYTHON3_OBJ) $(RUBY_OBJ) $(TCL_OBJ) \ + $(CSCOPE_OBJ) $(TERM_OBJ) $(NETBEANS_OBJ) $(CHANNEL_OBJ) $(XPM_OBJ) \ + version.c version.h + $(CC) $(CFLAGS_OUTDIR) version.c +! $(link) $(LINKARGS1) -out:$(VIM).exe $(OBJ) $(XDIFF_OBJ) $(GUI_OBJ) $(CUI_OBJ) $(OLE_OBJ) \ + $(LUA_OBJ) $(MZSCHEME_OBJ) $(PERL_OBJ) $(PYTHON_OBJ) $(PYTHON3_OBJ) $(RUBY_OBJ) \ + $(TCL_OBJ) $(CSCOPE_OBJ) $(TERM_OBJ) $(NETBEANS_OBJ) $(CHANNEL_OBJ) \ + $(XPM_OBJ) $(OUTDIR)\version.obj $(LINKARGS2) +*************** +*** 1304,1309 **** +--- 1322,1328 ---- + $(MAKE) /NOLOGO -f Make_dos.mak nolog + $(MAKE) /NOLOGO -f Make_dos.mak $@.res + $(MAKE) /NOLOGO -f Make_dos.mak report ++ cat messages + cd .. + + ########################################################################### +*************** +*** 1344,1349 **** +--- 1363,1386 ---- + + $(OUTDIR)/diff.obj: $(OUTDIR) diff.c $(INCL) + ++ $(OUTDIR)/xdiffi.obj: $(OUTDIR) xdiff/xdiffi.c $(XDIFF_DEPS) ++ $(CC) $(CFLAGS_OUTDIR) xdiff/xdiffi.c ++ ++ $(OUTDIR)/xemit.obj: $(OUTDIR) xdiff/xemit.c $(XDIFF_DEPS) ++ $(CC) $(CFLAGS_OUTDIR) xdiff/xemit.c ++ ++ $(OUTDIR)/xprepare.obj: $(OUTDIR) xdiff/xprepare.c $(XDIFF_DEPS) ++ $(CC) $(CFLAGS_OUTDIR) xdiff/xprepare.c ++ ++ $(OUTDIR)/xutils.obj: $(OUTDIR) xdiff/xutils.c $(XDIFF_DEPS) ++ $(CC) $(CFLAGS_OUTDIR) xdiff/xutils.c ++ ++ $(OUTDIR)/xhistogram.obj: $(OUTDIR) xdiff/xhistogram.c $(XDIFF_DEPS) ++ $(CC) $(CFLAGS_OUTDIR) xdiff/xhistogram.c ++ ++ $(OUTDIR)/xpatience.obj: $(OUTDIR) xdiff/xpatience.c $(XDIFF_DEPS) ++ $(CC) $(CFLAGS_OUTDIR) xdiff/xpatience.c ++ + $(OUTDIR)/digraph.obj: $(OUTDIR) digraph.c $(INCL) + + $(OUTDIR)/edit.obj: $(OUTDIR) edit.c $(INCL) +*** ../vim-8.1.0359/src/Makefile 2018-07-07 22:26:49.306702821 +0200 +--- src/Makefile 2018-09-10 17:32:57.212394678 +0200 +*************** +*** 1400,1405 **** +--- 1400,1431 ---- + + TERM_SRC = libvterm/src/*.c + ++ XDIFF_SRC = \ ++ xdiff/xdiffi.c \ ++ xdiff/xemit.c \ ++ xdiff/xprepare.c \ ++ xdiff/xutils.c \ ++ xdiff/xhistogram.c \ ++ xdiff/xpatience.c \ ++ ++ XDIFF_OBJS = \ ++ objects/xdiffi.o \ ++ objects/xemit.o \ ++ objects/xprepare.o \ ++ objects/xutils.o \ ++ objects/xhistogram.o \ ++ objects/xpatience.o \ ++ ++ XDIFF_INCL = \ ++ xdiff/xdiff.h \ ++ xdiff/xdiffi.h \ ++ xdiff/xemit.h \ ++ xdiff/xinclude.h \ ++ xdiff/xmacros.h \ ++ xdiff/xprepare.h \ ++ xdiff/xtypes.h \ ++ xdiff/xutils.h \ ++ + ### Command to create dependencies based on #include "..." + ### prototype headers are ignored due to -DPROTO, system + ### headers #include <...> are ignored if we use the -MM option, as +*************** +*** 1611,1616 **** +--- 1637,1643 ---- + SRC = $(BASIC_SRC) \ + $(GUI_SRC) \ + $(TERM_SRC) \ ++ $(XDIFF_SRC) \ + $(HANGULIN_SRC) \ + $(LUA_SRC) \ + $(MZSCHEME_SRC) \ +*************** +*** 1728,1733 **** +--- 1755,1761 ---- + $(WORKSHOP_OBJ) \ + $(NETBEANS_OBJ) \ + $(CHANNEL_OBJ) \ ++ $(XDIFF_OBJS) \ + $(WSDEBUG_OBJ) + + # The files included by tests are not in OBJ_COMMON. +*************** +*** 2731,2737 **** + + shadow: runtime pixmaps + $(MKDIR_P) $(SHADOWDIR) +! cd $(SHADOWDIR); ln -s ../*.[chm] ../*.in ../*.sh ../*.xs ../*.xbm ../gui_gtk_res.xml ../toolcheck ../proto ../libvterm ../vimtutor ../gvimtutor ../install-sh ../Make_all.mak . + mkdir $(SHADOWDIR)/auto + cd $(SHADOWDIR)/auto; ln -s ../../auto/configure . + $(MKDIR_P) $(SHADOWDIR)/po +--- 2759,2765 ---- + + shadow: runtime pixmaps + $(MKDIR_P) $(SHADOWDIR) +! cd $(SHADOWDIR); ln -s ../*.[chm] ../*.in ../*.sh ../*.xs ../*.xbm ../gui_gtk_res.xml ../toolcheck ../proto ../xdiff ../libvterm ../vimtutor ../gvimtutor ../install-sh ../Make_all.mak . + mkdir $(SHADOWDIR)/auto + cd $(SHADOWDIR)/auto; ln -s ../../auto/configure . + $(MKDIR_P) $(SHADOWDIR)/po +*************** +*** 2915,2921 **** + objects/dict.o: dict.c + $(CCC) -o $@ dict.c + +! objects/diff.o: diff.c + $(CCC) -o $@ diff.c + + objects/digraph.o: digraph.c +--- 2943,2949 ---- + objects/dict.o: dict.c + $(CCC) -o $@ dict.c + +! objects/diff.o: diff.c $(XDIFF_INCL) + $(CCC) -o $@ diff.c + + objects/digraph.o: digraph.c +*************** +*** 3229,3234 **** +--- 3257,3283 ---- + objects/term_vterm.o: libvterm/src/vterm.c $(TERM_DEPS) + $(CCCTERM) -o $@ libvterm/src/vterm.c + ++ CCCDIFF = $(CCC_NF) $(ALL_CFLAGS) ++ ++ objects/xdiffi.o: xdiff/xdiffi.c $(XDIFF_INCL) ++ $(CCCDIFF) -o $@ xdiff/xdiffi.c ++ ++ objects/xprepare.o: xdiff/xprepare.c $(XDIFF_INCL) ++ $(CCCDIFF) -o $@ xdiff/xprepare.c ++ ++ objects/xutils.o: xdiff/xutils.c $(XDIFF_INCL) ++ $(CCCDIFF) -o $@ xdiff/xutils.c ++ ++ objects/xemit.o: xdiff/xemit.c $(XDIFF_INCL) ++ $(CCCDIFF) -o $@ xdiff/xemit.c ++ ++ objects/xhistogram.o: xdiff/xhistogram.c $(XDIFF_INCL) ++ $(CCCDIFF) -o $@ xdiff/xhistogram.c ++ ++ objects/xpatience.o: xdiff/xpatience.c $(XDIFF_INCL) ++ $(CCCDIFF) -o $@ xdiff/xpatience.c ++ ++ + ############################################################################### + ### MacOS X installation + ### +*** ../vim-8.1.0359/src/diff.c 2018-06-03 14:42:17.840505115 +0200 +--- src/diff.c 2018-09-10 17:36:06.542197741 +0200 +*************** +*** 9,31 **** + + /* + * diff.c: code for diff'ing two, three or four buffers. + */ + + #include "vim.h" + + #if defined(FEAT_DIFF) || defined(PROTO) + + static int diff_busy = FALSE; /* ex_diffgetput() is busy */ + + /* flags obtained from the 'diffopt' option */ +! #define DIFF_FILLER 1 /* display filler lines */ +! #define DIFF_ICASE 2 /* ignore case */ +! #define DIFF_IWHITE 4 /* ignore change in white space */ +! #define DIFF_HORIZONTAL 8 /* horizontal splits */ +! #define DIFF_VERTICAL 16 /* vertical splits */ +! #define DIFF_HIDDEN_OFF 32 /* diffoff when hidden */ + static int diff_flags = DIFF_FILLER; + + #define LBUFLEN 50 /* length of line in diff file */ + + static int diff_a_works = MAYBE; /* TRUE when "diff -a" works, FALSE when it +--- 9,40 ---- + + /* + * diff.c: code for diff'ing two, three or four buffers. ++ * ++ * There are three ways to diff: ++ * - Shell out to an external diff program, using files. ++ * - Use the compiled-in xdiff library. ++ * - Let 'diffexpr' do the work, using files. + */ + + #include "vim.h" ++ #include "xdiff/xdiff.h" + + #if defined(FEAT_DIFF) || defined(PROTO) + + static int diff_busy = FALSE; /* ex_diffgetput() is busy */ + + /* flags obtained from the 'diffopt' option */ +! #define DIFF_FILLER 1 // display filler lines +! #define DIFF_ICASE 2 // ignore case +! #define DIFF_IWHITE 4 // ignore change in white space +! #define DIFF_HORIZONTAL 8 // horizontal splits +! #define DIFF_VERTICAL 16 // vertical splits +! #define DIFF_HIDDEN_OFF 32 // diffoff when hidden +! #define DIFF_INTERNAL 64 // use internal xdiff algorithm + static int diff_flags = DIFF_FILLER; + ++ static long diff_algorithm = 0; ++ + #define LBUFLEN 50 /* length of line in diff file */ + + static int diff_a_works = MAYBE; /* TRUE when "diff -a" works, FALSE when it +*************** +*** 36,57 **** + checked yet */ + #endif + + static int diff_buf_idx(buf_T *buf); + static int diff_buf_idx_tp(buf_T *buf, tabpage_T *tp); + static void diff_mark_adjust_tp(tabpage_T *tp, int idx, linenr_T line1, linenr_T line2, long amount, long amount_after); + static void diff_check_unchanged(tabpage_T *tp, diff_T *dp); + static int diff_check_sanity(tabpage_T *tp, diff_T *dp); + static void diff_redraw(int dofold); +! static int diff_write(buf_T *buf, char_u *fname); +! static void diff_file(char_u *tmp_orig, char_u *tmp_new, char_u *tmp_diff); + static int diff_equal_entry(diff_T *dp, int idx1, int idx2); + static int diff_cmp(char_u *s1, char_u *s2); + #ifdef FEAT_FOLDING + static void diff_fold_update(diff_T *dp, int skip_idx); + #endif +! static void diff_read(int idx_orig, int idx_new, char_u *fname); + static void diff_copy_entry(diff_T *dprev, diff_T *dp, int idx_orig, int idx_new); + static diff_T *diff_alloc_new(tabpage_T *tp, diff_T *dprev, diff_T *dp); + + #ifndef USE_CR + # define tag_fgets vim_fgets +--- 45,89 ---- + checked yet */ + #endif + ++ // used for diff input ++ typedef struct { ++ char_u *din_fname; // used for external diff ++ mmfile_t din_mmfile; // used for internal diff ++ } diffin_T; ++ ++ // used for diff result ++ typedef struct { ++ char_u *dout_fname; // used for external diff ++ garray_T dout_ga; // used for internal diff ++ } diffout_T; ++ ++ // two diff inputs and one result ++ typedef struct { ++ diffin_T dio_orig; // original file input ++ diffin_T dio_new; // new file input ++ diffout_T dio_diff; // diff result ++ int dio_internal; // using internal diff ++ } diffio_T; ++ + static int diff_buf_idx(buf_T *buf); + static int diff_buf_idx_tp(buf_T *buf, tabpage_T *tp); + static void diff_mark_adjust_tp(tabpage_T *tp, int idx, linenr_T line1, linenr_T line2, long amount, long amount_after); + static void diff_check_unchanged(tabpage_T *tp, diff_T *dp); + static int diff_check_sanity(tabpage_T *tp, diff_T *dp); + static void diff_redraw(int dofold); +! static int check_external_diff(diffio_T *diffio); +! static int diff_file(diffio_T *diffio); + static int diff_equal_entry(diff_T *dp, int idx1, int idx2); + static int diff_cmp(char_u *s1, char_u *s2); + #ifdef FEAT_FOLDING + static void diff_fold_update(diff_T *dp, int skip_idx); + #endif +! static void diff_read(int idx_orig, int idx_new, diffout_T *fname); + static void diff_copy_entry(diff_T *dprev, diff_T *dp, int idx_orig, int idx_new); + static diff_T *diff_alloc_new(tabpage_T *tp, diff_T *dprev, diff_T *dp); ++ static int parse_diff_ed(char_u *line, linenr_T *lnum_orig, long *count_orig, linenr_T *lnum_new, long *count_new); ++ static int parse_diff_unified(char_u *line, linenr_T *lnum_orig, long *count_orig, linenr_T *lnum_new, long *count_new); ++ static int xdiff_out(void *priv, mmbuffer_t *mb, int nbuf); + + #ifndef USE_CR + # define tag_fgets vim_fgets +*************** +*** 631,711 **** + } + } + + /* +! * Write buffer "buf" to file "name". +! * Always use 'fileformat' set to "unix". +! * Return FAIL for failure + */ + static int +! diff_write(buf_T *buf, char_u *fname) + { + int r; + char_u *save_ff; + + save_ff = buf->b_p_ff; + buf->b_p_ff = vim_strsave((char_u *)FF_UNIX); +! r = buf_write(buf, fname, NULL, (linenr_T)1, buf->b_ml.ml_line_count, +! NULL, FALSE, FALSE, FALSE, TRUE); + free_string_option(buf->b_p_ff); + buf->b_p_ff = save_ff; + return r; + } + + /* + * Completely update the diffs for the buffers involved. + * This uses the ordinary "diff" command. + * The buffers are written to a file, also for unmodified buffers (the file + * could have been produced by autocommands, e.g. the netrw plugin). + */ + void +! ex_diffupdate( +! exarg_T *eap) /* can be NULL */ + { +- buf_T *buf; + int idx_orig; + int idx_new; +! char_u *tmp_orig; +! char_u *tmp_new; +! char_u *tmp_diff; +! FILE *fd; +! int ok; +! int io_error = FALSE; + +! /* Delete all diffblocks. */ + diff_clear(curtab); + curtab->tp_diff_invalid = FALSE; + +! /* Use the first buffer as the original text. */ + for (idx_orig = 0; idx_orig < DB_COUNT; ++idx_orig) + if (curtab->tp_diffbuf[idx_orig] != NULL) + break; + if (idx_orig == DB_COUNT) + return; + +! /* Only need to do something when there is another buffer. */ + for (idx_new = idx_orig + 1; idx_new < DB_COUNT; ++idx_new) + if (curtab->tp_diffbuf[idx_new] != NULL) + break; + if (idx_new == DB_COUNT) + return; + +! /* We need three temp file names. */ +! tmp_orig = vim_tempname('o', TRUE); +! tmp_new = vim_tempname('n', TRUE); +! tmp_diff = vim_tempname('d', TRUE); +! if (tmp_orig == NULL || tmp_new == NULL || tmp_diff == NULL) +! goto theend; + +! /* +! * Do a quick test if "diff" really works. Otherwise it looks like there +! * are no differences. Can't use the return value, it's non-zero when +! * there are differences. +! * May try twice, first with "-a" and then without. +! */ + for (;;) + { + ok = FALSE; +! fd = mch_fopen((char *)tmp_orig, "w"); + if (fd == NULL) + io_error = TRUE; + else +--- 663,952 ---- + } + } + ++ static void ++ clear_diffin(diffin_T *din) ++ { ++ if (din->din_fname == NULL) ++ { ++ vim_free(din->din_mmfile.ptr); ++ din->din_mmfile.ptr = NULL; ++ } ++ else ++ mch_remove(din->din_fname); ++ } ++ ++ static void ++ clear_diffout(diffout_T *dout) ++ { ++ if (dout->dout_fname == NULL) ++ ga_clear_strings(&dout->dout_ga); ++ else ++ mch_remove(dout->dout_fname); ++ } ++ + /* +! * Write buffer "buf" to a memory buffer. +! * Return FAIL for failure. + */ + static int +! diff_write_buffer(buf_T *buf, diffin_T *din) +! { +! linenr_T lnum; +! char_u *s; +! long len = 0; +! char_u *ptr; +! +! // xdiff requires one big block of memory with all the text. +! for (lnum = 1; lnum <= buf->b_ml.ml_line_count; ++lnum) +! len += STRLEN(ml_get_buf(buf, lnum, FALSE)) + 1; +! ptr = lalloc(len, TRUE); +! if (ptr == NULL) +! { +! // Allocating memory failed. This can happen, because we try to read +! // the whole buffer text into memory. Set the failed flag, the diff +! // will be retried with external diff. The flag is never reset. +! buf->b_diff_failed = TRUE; +! if (p_verbose > 0) +! { +! verbose_enter(); +! smsg((char_u *) +! _("Not enough memory to use internal diff for buffer \"%s\""), +! buf->b_fname); +! verbose_leave(); +! } +! return FAIL; +! } +! din->din_mmfile.ptr = (char *)ptr; +! din->din_mmfile.size = len; +! +! len = 0; +! for (lnum = 1; lnum <= buf->b_ml.ml_line_count; ++lnum) +! { +! for (s = ml_get_buf(buf, lnum, FALSE); *s != NUL; ) +! { +! if (diff_flags & DIFF_ICASE) +! { +! int c; +! +! // xdiff doesn't support ignoring case, fold-case the text. +! #ifdef FEAT_MBYTE +! int orig_len; +! char_u cbuf[MB_MAXBYTES + 1]; +! +! c = PTR2CHAR(s); +! c = enc_utf8 ? utf_fold(c) : MB_TOLOWER(c); +! orig_len = MB_PTR2LEN(s); +! if (mb_char2bytes(c, cbuf) != orig_len) +! // TODO: handle byte length difference +! mch_memmove(ptr + len, s, orig_len); +! else +! mch_memmove(ptr + len, cbuf, orig_len); +! +! s += orig_len; +! len += orig_len; +! #else +! c = *s++; +! ptr[len++] = TOLOWER_LOC(c); +! #endif +! } +! else +! ptr[len++] = *s++; +! } +! ptr[len++] = NL; +! } +! return OK; +! } +! +! /* +! * Write buffer "buf" to file or memory buffer. +! * Return FAIL for failure. +! */ +! static int +! diff_write(buf_T *buf, diffin_T *din) + { + int r; + char_u *save_ff; + ++ if (din->din_fname == NULL) ++ return diff_write_buffer(buf, din); ++ ++ // Always use 'fileformat' set to "unix". + save_ff = buf->b_p_ff; + buf->b_p_ff = vim_strsave((char_u *)FF_UNIX); +! r = buf_write(buf, din->din_fname, NULL, +! (linenr_T)1, buf->b_ml.ml_line_count, +! NULL, FALSE, FALSE, FALSE, TRUE); + free_string_option(buf->b_p_ff); + buf->b_p_ff = save_ff; + return r; + } + + /* ++ * Update the diffs for all buffers involved. ++ */ ++ static void ++ diff_try_update( ++ diffio_T *dio, ++ int idx_orig, ++ exarg_T *eap) // "eap" can be NULL ++ { ++ buf_T *buf; ++ int idx_new; ++ ++ if (dio->dio_internal) ++ { ++ ga_init2(&dio->dio_diff.dout_ga, sizeof(char *), 1000); ++ } ++ else ++ { ++ // We need three temp file names. ++ dio->dio_orig.din_fname = vim_tempname('o', TRUE); ++ dio->dio_new.din_fname = vim_tempname('n', TRUE); ++ dio->dio_diff.dout_fname = vim_tempname('d', TRUE); ++ if (dio->dio_orig.din_fname == NULL ++ || dio->dio_new.din_fname == NULL ++ || dio->dio_diff.dout_fname == NULL) ++ goto theend; ++ } ++ ++ // Check external diff is actually working. ++ if (!dio->dio_internal && check_external_diff(dio) == FAIL) ++ goto theend; ++ ++ // :diffupdate! ++ if (eap != NULL && eap->forceit) ++ for (idx_new = idx_orig; idx_new < DB_COUNT; ++idx_new) ++ { ++ buf = curtab->tp_diffbuf[idx_new]; ++ if (buf_valid(buf)) ++ buf_check_timestamp(buf, FALSE); ++ } ++ ++ // Write the first buffer to a tempfile or mmfile_t. ++ buf = curtab->tp_diffbuf[idx_orig]; ++ if (diff_write(buf, &dio->dio_orig) == FAIL) ++ goto theend; ++ ++ // Make a difference between the first buffer and every other. ++ for (idx_new = idx_orig + 1; idx_new < DB_COUNT; ++idx_new) ++ { ++ buf = curtab->tp_diffbuf[idx_new]; ++ if (buf == NULL || buf->b_ml.ml_mfp == NULL) ++ continue; // skip buffer that isn't loaded ++ ++ // Write the other buffer and diff with the first one. ++ if (diff_write(buf, &dio->dio_new) == FAIL) ++ continue; ++ if (diff_file(dio) == FAIL) ++ continue; ++ ++ // Read the diff output and add each entry to the diff list. ++ diff_read(idx_orig, idx_new, &dio->dio_diff); ++ ++ clear_diffin(&dio->dio_new); ++ clear_diffout(&dio->dio_diff); ++ } ++ clear_diffin(&dio->dio_orig); ++ ++ theend: ++ vim_free(dio->dio_orig.din_fname); ++ vim_free(dio->dio_new.din_fname); ++ vim_free(dio->dio_diff.dout_fname); ++ } ++ ++ /* ++ * Return TRUE if the options are set to use the internal diff library. ++ * Note that if the internal diff failed for one of the buffers, the external ++ * diff will be used anyway. ++ */ ++ static int ++ diff_internal(void) ++ { ++ return (diff_flags & DIFF_INTERNAL) != 0 && *p_dex == NUL; ++ } ++ ++ /* ++ * Return TRUE if the internal diff failed for one of the diff buffers. ++ */ ++ static int ++ diff_internal_failed(void) ++ { ++ int idx; ++ ++ // Only need to do something when there is another buffer. ++ for (idx = 0; idx < DB_COUNT; ++idx) ++ if (curtab->tp_diffbuf[idx] != NULL ++ && curtab->tp_diffbuf[idx]->b_diff_failed) ++ return TRUE; ++ return FALSE; ++ } ++ ++ /* + * Completely update the diffs for the buffers involved. + * This uses the ordinary "diff" command. + * The buffers are written to a file, also for unmodified buffers (the file + * could have been produced by autocommands, e.g. the netrw plugin). + */ + void +! ex_diffupdate(exarg_T *eap) // "eap" can be NULL + { + int idx_orig; + int idx_new; +! diffio_T diffio; + +! // Delete all diffblocks. + diff_clear(curtab); + curtab->tp_diff_invalid = FALSE; + +! // Use the first buffer as the original text. + for (idx_orig = 0; idx_orig < DB_COUNT; ++idx_orig) + if (curtab->tp_diffbuf[idx_orig] != NULL) + break; + if (idx_orig == DB_COUNT) + return; + +! // Only need to do something when there is another buffer. + for (idx_new = idx_orig + 1; idx_new < DB_COUNT; ++idx_new) + if (curtab->tp_diffbuf[idx_new] != NULL) + break; + if (idx_new == DB_COUNT) + return; + +! // Only use the internal method if it did not fail for one of the buffers. +! vim_memset(&diffio, 0, sizeof(diffio)); +! diffio.dio_internal = diff_internal() && !diff_internal_failed(); +! +! diff_try_update(&diffio, idx_orig, eap); +! if (diffio.dio_internal && diff_internal_failed()) +! { +! // Internal diff failed, use external diff instead. +! vim_memset(&diffio, 0, sizeof(diffio)); +! diff_try_update(&diffio, idx_orig, eap); +! } + +! // force updating cursor position on screen +! curwin->w_valid_cursor.lnum = 0; +! +! diff_redraw(TRUE); +! } +! +! /* +! * Do a quick test if "diff" really works. Otherwise it looks like there +! * are no differences. Can't use the return value, it's non-zero when +! * there are differences. +! */ +! static int +! check_external_diff(diffio_T *diffio) +! { +! FILE *fd; +! int ok; +! int io_error = FALSE; +! +! // May try twice, first with "-a" and then without. + for (;;) + { + ok = FALSE; +! fd = mch_fopen((char *)diffio->dio_orig.din_fname, "w"); + if (fd == NULL) + io_error = TRUE; + else +*************** +*** 713,719 **** + if (fwrite("line1\n", (size_t)6, (size_t)1, fd) != 1) + io_error = TRUE; + fclose(fd); +! fd = mch_fopen((char *)tmp_new, "w"); + if (fd == NULL) + io_error = TRUE; + else +--- 954,960 ---- + if (fwrite("line1\n", (size_t)6, (size_t)1, fd) != 1) + io_error = TRUE; + fclose(fd); +! fd = mch_fopen((char *)diffio->dio_new.din_fname, "w"); + if (fd == NULL) + io_error = TRUE; + else +*************** +*** 721,728 **** + if (fwrite("line2\n", (size_t)6, (size_t)1, fd) != 1) + io_error = TRUE; + fclose(fd); +! diff_file(tmp_orig, tmp_new, tmp_diff); +! fd = mch_fopen((char *)tmp_diff, "r"); + if (fd == NULL) + io_error = TRUE; + else +--- 962,970 ---- + if (fwrite("line2\n", (size_t)6, (size_t)1, fd) != 1) + io_error = TRUE; + fclose(fd); +! fd = NULL; +! if (diff_file(diffio) == OK) +! fd = mch_fopen((char *)diffio->dio_diff.dout_fname, "r"); + if (fd == NULL) + io_error = TRUE; + else +*************** +*** 739,748 **** + } + fclose(fd); + } +! mch_remove(tmp_diff); +! mch_remove(tmp_new); + } +! mch_remove(tmp_orig); + } + + #ifdef FEAT_EVAL +--- 981,990 ---- + } + fclose(fd); + } +! mch_remove(diffio->dio_diff.dout_fname); +! mch_remove(diffio->dio_new.din_fname); + } +! mch_remove(diffio->dio_orig.din_fname); + } + + #ifdef FEAT_EVAL +*************** +*** 785,882 **** + #if defined(MSWIN) + diff_bin_works = MAYBE; + #endif +! goto theend; + } + +! /* :diffupdate! */ +! if (eap != NULL && eap->forceit) +! for (idx_new = idx_orig; idx_new < DB_COUNT; ++idx_new) +! { +! buf = curtab->tp_diffbuf[idx_new]; +! if (buf_valid(buf)) +! buf_check_timestamp(buf, FALSE); +! } +! +! /* Write the first buffer to a tempfile. */ +! buf = curtab->tp_diffbuf[idx_orig]; +! if (diff_write(buf, tmp_orig) == FAIL) +! goto theend; +! +! /* Make a difference between the first buffer and every other. */ +! for (idx_new = idx_orig + 1; idx_new < DB_COUNT; ++idx_new) +! { +! buf = curtab->tp_diffbuf[idx_new]; +! if (buf == NULL || buf->b_ml.ml_mfp == NULL) +! continue; /* skip buffer that isn't loaded */ +! if (diff_write(buf, tmp_new) == FAIL) +! continue; +! diff_file(tmp_orig, tmp_new, tmp_diff); + +! /* Read the diff output and add each entry to the diff list. */ +! diff_read(idx_orig, idx_new, tmp_diff); +! mch_remove(tmp_diff); +! mch_remove(tmp_new); +! } +! mch_remove(tmp_orig); + +! /* force updating cursor position on screen */ +! curwin->w_valid_cursor.lnum = 0; + +! diff_redraw(TRUE); + +! theend: +! vim_free(tmp_orig); +! vim_free(tmp_new); +! vim_free(tmp_diff); + } + + /* + * Make a diff between files "tmp_orig" and "tmp_new", results in "tmp_diff". + */ +! static void +! diff_file( +! char_u *tmp_orig, +! char_u *tmp_new, +! char_u *tmp_diff) + { + char_u *cmd; + size_t len; + + #ifdef FEAT_EVAL + if (*p_dex != NUL) +! /* Use 'diffexpr' to generate the diff file. */ + eval_diff(tmp_orig, tmp_new, tmp_diff); + else + #endif + { + len = STRLEN(tmp_orig) + STRLEN(tmp_new) + + STRLEN(tmp_diff) + STRLEN(p_srr) + 27; + cmd = alloc((unsigned)len); +! if (cmd != NULL) +! { +! /* We don't want $DIFF_OPTIONS to get in the way. */ +! if (getenv("DIFF_OPTIONS")) +! vim_setenv((char_u *)"DIFF_OPTIONS", (char_u *)""); +! +! /* Build the diff command and execute it. Always use -a, binary +! * differences are of no use. Ignore errors, diff returns +! * non-zero when differences have been found. */ +! vim_snprintf((char *)cmd, len, "diff %s%s%s%s%s %s", +! diff_a_works == FALSE ? "" : "-a ", + #if defined(MSWIN) +! diff_bin_works == TRUE ? "--binary " : "", + #else +! "", + #endif +! (diff_flags & DIFF_IWHITE) ? "-b " : "", +! (diff_flags & DIFF_ICASE) ? "-i " : "", +! tmp_orig, tmp_new); +! append_redir(cmd, (int)len, p_srr, tmp_diff); +! block_autocmds(); /* Avoid ShellCmdPost stuff */ +! (void)call_shell(cmd, SHELL_FILTER|SHELL_SILENT|SHELL_DOOUT); +! unblock_autocmds(); +! vim_free(cmd); +! } + } + } + +--- 1027,1127 ---- + #if defined(MSWIN) + diff_bin_works = MAYBE; + #endif +! return FAIL; + } ++ return OK; ++ } + +! /* +! * Invoke the xdiff function. +! */ +! static int +! diff_file_internal(diffio_T *diffio) +! { +! xpparam_t param; +! xdemitconf_t emit_cfg; +! xdemitcb_t emit_cb; + +! vim_memset(¶m, 0, sizeof(param)); +! vim_memset(&emit_cfg, 0, sizeof(emit_cfg)); +! vim_memset(&emit_cb, 0, sizeof(emit_cb)); + +! param.flags = diff_algorithm; + +! if (diff_flags & DIFF_IWHITE) +! param.flags |= XDF_IGNORE_WHITESPACE_CHANGE; + +! emit_cfg.ctxlen = 0; // don't need any diff_context here +! emit_cb.priv = &diffio->dio_diff; +! emit_cb.outf = xdiff_out; +! if (xdl_diff(&diffio->dio_orig.din_mmfile, +! &diffio->dio_new.din_mmfile, +! ¶m, &emit_cfg, &emit_cb) < 0) +! { +! EMSG(_("E960: Problem creating the internal diff")); +! return FAIL; +! } +! return OK; + } + + /* + * Make a diff between files "tmp_orig" and "tmp_new", results in "tmp_diff". ++ * return OK or FAIL; + */ +! static int +! diff_file(diffio_T *dio) + { + char_u *cmd; + size_t len; ++ char_u *tmp_orig = dio->dio_orig.din_fname; ++ char_u *tmp_new = dio->dio_new.din_fname; ++ char_u *tmp_diff = dio->dio_diff.dout_fname; + + #ifdef FEAT_EVAL + if (*p_dex != NUL) +! { +! // Use 'diffexpr' to generate the diff file. + eval_diff(tmp_orig, tmp_new, tmp_diff); ++ return OK; ++ } + else + #endif ++ // Use xdiff for generating the diff. ++ if (dio->dio_internal) ++ { ++ return diff_file_internal(dio); ++ } ++ else + { + len = STRLEN(tmp_orig) + STRLEN(tmp_new) + + STRLEN(tmp_diff) + STRLEN(p_srr) + 27; + cmd = alloc((unsigned)len); +! if (cmd == NULL) +! return FAIL; +! +! // We don't want $DIFF_OPTIONS to get in the way. +! if (getenv("DIFF_OPTIONS")) +! vim_setenv((char_u *)"DIFF_OPTIONS", (char_u *)""); +! +! // Build the diff command and execute it. Always use -a, binary +! // differences are of no use. Ignore errors, diff returns +! // non-zero when differences have been found. +! vim_snprintf((char *)cmd, len, "diff %s%s%s%s%s %s", +! diff_a_works == FALSE ? "" : "-a ", + #if defined(MSWIN) +! diff_bin_works == TRUE ? "--binary " : "", + #else +! "", + #endif +! (diff_flags & DIFF_IWHITE) ? "-b " : "", +! (diff_flags & DIFF_ICASE) ? "-i " : "", +! tmp_orig, tmp_new); +! append_redir(cmd, (int)len, p_srr, tmp_diff); +! block_autocmds(); // avoid ShellCmdPost stuff +! (void)call_shell(cmd, SHELL_FILTER|SHELL_SILENT|SHELL_DOOUT); +! unblock_autocmds(); +! vim_free(cmd); +! return OK; + } + } + +*************** +*** 1282,1370 **** + */ + static void + diff_read( +! int idx_orig, /* idx of original file */ +! int idx_new, /* idx of new file */ +! char_u *fname) /* name of diff output file */ + { +! FILE *fd; + diff_T *dprev = NULL; + diff_T *dp = curtab->tp_first_diff; + diff_T *dn, *dpl; +- long f1, l1, f2, l2; + char_u linebuf[LBUFLEN]; /* only need to hold the diff line */ +! int difftype; +! char_u *p; + long off; + int i; + linenr_T lnum_orig, lnum_new; + long count_orig, count_new; + int notset = TRUE; /* block "*dp" not set yet */ + +! fd = mch_fopen((char *)fname, "r"); +! if (fd == NULL) + { +! EMSG(_("E98: Cannot read diff output")); +! return; + } +! +! for (;;) + { +! if (tag_fgets(linebuf, LBUFLEN, fd)) +! break; /* end of file */ +! if (!isdigit(*linebuf)) +! continue; /* not the start of a diff block */ +! +! /* This line must be one of three formats: +! * {first}[,{last}]c{first}[,{last}] +! * {first}a{first}[,{last}] +! * {first}[,{last}]d{first} +! */ +! p = linebuf; +! f1 = getdigits(&p); +! if (*p == ',') +! { +! ++p; +! l1 = getdigits(&p); +! } +! else +! l1 = f1; +! if (*p != 'a' && *p != 'c' && *p != 'd') +! continue; /* invalid diff format */ +! difftype = *p++; +! f2 = getdigits(&p); +! if (*p == ',') + { +! ++p; +! l2 = getdigits(&p); + } +! else +! l2 = f2; +! if (l1 < f1 || l2 < f2) +! continue; /* invalid line range */ + +! if (difftype == 'a') + { +! lnum_orig = f1 + 1; +! count_orig = 0; + } + else + { +! lnum_orig = f1; +! count_orig = l1 - f1 + 1; + } +! if (difftype == 'd') + { +! lnum_new = f2 + 1; +! count_new = 0; + } + else + { +! lnum_new = f2; +! count_new = l2 - f2 + 1; + } + +! /* Go over blocks before the change, for which orig and new are equal. +! * Copy blocks from orig to new. */ + while (dp != NULL + && lnum_orig > dp->df_lnum[idx_orig] + dp->df_count[idx_orig]) + { +--- 1527,1631 ---- + */ + static void + diff_read( +! int idx_orig, // idx of original file +! int idx_new, // idx of new file +! diffout_T *dout) // diff output + { +! FILE *fd = NULL; +! int line_idx = 0; + diff_T *dprev = NULL; + diff_T *dp = curtab->tp_first_diff; + diff_T *dn, *dpl; + char_u linebuf[LBUFLEN]; /* only need to hold the diff line */ +! char_u *line; + long off; + int i; + linenr_T lnum_orig, lnum_new; + long count_orig, count_new; + int notset = TRUE; /* block "*dp" not set yet */ ++ enum { ++ DIFF_ED, ++ DIFF_UNIFIED, ++ DIFF_NONE ++ } diffstyle = DIFF_NONE; + +! if (dout->dout_fname == NULL) + { +! diffstyle = DIFF_UNIFIED; + } +! else + { +! fd = mch_fopen((char *)dout->dout_fname, "r"); +! if (fd == NULL) + { +! EMSG(_("E98: Cannot read diff output")); +! return; + } +! } + +! for (;;) +! { +! if (fd == NULL) + { +! if (line_idx >= dout->dout_ga.ga_len) +! break; // did last line +! line = ((char_u **)dout->dout_ga.ga_data)[line_idx++]; + } + else + { +! if (tag_fgets(linebuf, LBUFLEN, fd)) +! break; // end of file +! line = linebuf; +! } +! +! if (diffstyle == DIFF_NONE) +! { +! // Determine diff style. +! // ed like diff looks like this: +! // {first}[,{last}]c{first}[,{last}] +! // {first}a{first}[,{last}] +! // {first}[,{last}]d{first} +! // +! // unified diff looks like this: +! // --- file1 2018-03-20 13:23:35.783153140 +0100 +! // +++ file2 2018-03-20 13:23:41.183156066 +0100 +! // @@ -1,3 +1,5 @@ +! if (isdigit(*line)) +! diffstyle = DIFF_ED; +! else if ((STRNCMP(line, "@@ ", 3) == 0)) +! diffstyle = DIFF_UNIFIED; +! else if ((STRNCMP(line, "--- ", 4) == 0) +! && (tag_fgets(linebuf, LBUFLEN, fd) == 0) +! && (STRNCMP(line, "+++ ", 4) == 0) +! && (tag_fgets(linebuf, LBUFLEN, fd) == 0) +! && (STRNCMP(line, "@@ ", 3) == 0)) +! diffstyle = DIFF_UNIFIED; +! } +! +! if (diffstyle == DIFF_ED) +! { +! if (!isdigit(*line)) +! continue; // not the start of a diff block +! if (parse_diff_ed(line, &lnum_orig, &count_orig, +! &lnum_new, &count_new) == FAIL) +! continue; + } +! else if (diffstyle == DIFF_UNIFIED) + { +! if (STRNCMP(line, "@@ ", 3) != 0) +! continue; // not the start of a diff block +! if (parse_diff_unified(line, &lnum_orig, &count_orig, +! &lnum_new, &count_new) == FAIL) +! continue; + } + else + { +! EMSG(_("E959: Invalid diff format.")); +! break; + } + +! // Go over blocks before the change, for which orig and new are equal. +! // Copy blocks from orig to new. + while (dp != NULL + && lnum_orig > dp->df_lnum[idx_orig] + dp->df_count[idx_orig]) + { +*************** +*** 1379,1392 **** + && lnum_orig <= dp->df_lnum[idx_orig] + dp->df_count[idx_orig] + && lnum_orig + count_orig >= dp->df_lnum[idx_orig]) + { +! /* New block overlaps with existing block(s). +! * First find last block that overlaps. */ + for (dpl = dp; dpl->df_next != NULL; dpl = dpl->df_next) + if (lnum_orig + count_orig < dpl->df_next->df_lnum[idx_orig]) + break; + +! /* If the newly found block starts before the old one, set the +! * start back a number of lines. */ + off = dp->df_lnum[idx_orig] - lnum_orig; + if (off > 0) + { +--- 1640,1653 ---- + && lnum_orig <= dp->df_lnum[idx_orig] + dp->df_count[idx_orig] + && lnum_orig + count_orig >= dp->df_lnum[idx_orig]) + { +! // New block overlaps with existing block(s). +! // First find last block that overlaps. + for (dpl = dp; dpl->df_next != NULL; dpl = dpl->df_next) + if (lnum_orig + count_orig < dpl->df_next->df_lnum[idx_orig]) + break; + +! // If the newly found block starts before the old one, set the +! // start back a number of lines. + off = dp->df_lnum[idx_orig] - lnum_orig; + if (off > 0) + { +*************** +*** 1398,1421 **** + } + else if (notset) + { +! /* new block inside existing one, adjust new block */ + dp->df_lnum[idx_new] = lnum_new + off; + dp->df_count[idx_new] = count_new - off; + } + else +! /* second overlap of new block with existing block */ + dp->df_count[idx_new] += count_new - count_orig + + dpl->df_lnum[idx_orig] + dpl->df_count[idx_orig] + - (dp->df_lnum[idx_orig] + dp->df_count[idx_orig]); + +! /* Adjust the size of the block to include all the lines to the +! * end of the existing block or the new diff, whatever ends last. */ + off = (lnum_orig + count_orig) + - (dpl->df_lnum[idx_orig] + dpl->df_count[idx_orig]); + if (off < 0) + { +! /* new change ends in existing block, adjust the end if not +! * done already */ + if (notset) + dp->df_count[idx_new] += -off; + off = 0; +--- 1659,1682 ---- + } + else if (notset) + { +! // new block inside existing one, adjust new block + dp->df_lnum[idx_new] = lnum_new + off; + dp->df_count[idx_new] = count_new - off; + } + else +! // second overlap of new block with existing block + dp->df_count[idx_new] += count_new - count_orig + + dpl->df_lnum[idx_orig] + dpl->df_count[idx_orig] + - (dp->df_lnum[idx_orig] + dp->df_count[idx_orig]); + +! // Adjust the size of the block to include all the lines to the +! // end of the existing block or the new diff, whatever ends last. + off = (lnum_orig + count_orig) + - (dpl->df_lnum[idx_orig] + dpl->df_count[idx_orig]); + if (off < 0) + { +! // new change ends in existing block, adjust the end if not +! // done already + if (notset) + dp->df_count[idx_new] += -off; + off = 0; +*************** +*** 1425,1431 **** + dp->df_count[i] = dpl->df_lnum[i] + dpl->df_count[i] + - dp->df_lnum[i] + off; + +! /* Delete the diff blocks that have been merged into one. */ + dn = dp->df_next; + dp->df_next = dpl->df_next; + while (dn != dp->df_next) +--- 1686,1692 ---- + dp->df_count[i] = dpl->df_lnum[i] + dpl->df_count[i] + - dp->df_lnum[i] + off; + +! // Delete the diff blocks that have been merged into one. + dn = dp->df_next; + dp->df_next = dpl->df_next; + while (dn != dp->df_next) +*************** +*** 1437,1443 **** + } + else + { +! /* Allocate a new diffblock. */ + dp = diff_alloc_new(curtab, dprev, dp); + if (dp == NULL) + goto done; +--- 1698,1704 ---- + } + else + { +! // Allocate a new diffblock. + dp = diff_alloc_new(curtab, dprev, dp); + if (dp == NULL) + goto done; +*************** +*** 1447,1463 **** + dp->df_lnum[idx_new] = lnum_new; + dp->df_count[idx_new] = count_new; + +! /* Set values for other buffers, these must be equal to the +! * original buffer, otherwise there would have been a change +! * already. */ + for (i = idx_orig + 1; i < idx_new; ++i) + if (curtab->tp_diffbuf[i] != NULL) + diff_copy_entry(dprev, dp, idx_orig, i); + } +! notset = FALSE; /* "*dp" has been set */ + } + +! /* for remaining diff blocks orig and new are equal */ + while (dp != NULL) + { + if (notset) +--- 1708,1724 ---- + dp->df_lnum[idx_new] = lnum_new; + dp->df_count[idx_new] = count_new; + +! // Set values for other buffers, these must be equal to the +! // original buffer, otherwise there would have been a change +! // already. + for (i = idx_orig + 1; i < idx_new; ++i) + if (curtab->tp_diffbuf[i] != NULL) + diff_copy_entry(dprev, dp, idx_orig, i); + } +! notset = FALSE; // "*dp" has been set + } + +! // for remaining diff blocks orig and new are equal + while (dp != NULL) + { + if (notset) +*************** +*** 1468,1474 **** + } + + done: +! fclose(fd); + } + + /* +--- 1729,1736 ---- + } + + done: +! if (fd != NULL) +! fclose(fd); + } + + /* +*************** +*** 1860,1865 **** +--- 2122,2128 ---- + int diff_context_new = 6; + int diff_flags_new = 0; + int diff_foldcolumn_new = 2; ++ long diff_algorithm_new = 0; + tabpage_T *tp; + + p = p_dip; +*************** +*** 1905,1910 **** +--- 2168,2208 ---- + p += 9; + diff_flags_new |= DIFF_HIDDEN_OFF; + } ++ else if (STRNCMP(p, "indent-heuristic", 16) == 0) ++ { ++ p += 16; ++ diff_algorithm_new |= XDF_INDENT_HEURISTIC; ++ } ++ else if (STRNCMP(p, "internal", 8) == 0) ++ { ++ p += 8; ++ diff_flags_new |= DIFF_INTERNAL; ++ } ++ else if (STRNCMP(p, "algorithm:", 10) == 0) ++ { ++ p += 10; ++ if (STRNCMP(p, "myers", 5) == 0) ++ { ++ p += 5; ++ diff_algorithm_new = 0; ++ } ++ else if (STRNCMP(p, "minimal", 7) == 0) ++ { ++ p += 7; ++ diff_algorithm_new = XDF_NEED_MINIMAL; ++ } ++ else if (STRNCMP(p, "patience", 8) == 0) ++ { ++ p += 8; ++ diff_algorithm_new = XDF_PATIENCE_DIFF; ++ } ++ else if (STRNCMP(p, "histogram", 9) == 0) ++ { ++ p += 9; ++ diff_algorithm_new = XDF_HISTOGRAM_DIFF; ++ } ++ } ++ + if (*p != ',' && *p != NUL) + return FAIL; + if (*p == ',') +*************** +*** 1916,1928 **** + return FAIL; + + /* If "icase" or "iwhite" was added or removed, need to update the diff. */ +! if (diff_flags != diff_flags_new) + FOR_ALL_TABPAGES(tp) + tp->tp_diff_invalid = TRUE; + + diff_flags = diff_flags_new; + diff_context = diff_context_new; + diff_foldcolumn = diff_foldcolumn_new; + + diff_redraw(TRUE); + +--- 2214,2227 ---- + return FAIL; + + /* If "icase" or "iwhite" was added or removed, need to update the diff. */ +! if (diff_flags != diff_flags_new || diff_algorithm != diff_algorithm_new) + FOR_ALL_TABPAGES(tp) + tp->tp_diff_invalid = TRUE; + + diff_flags = diff_flags_new; + diff_context = diff_context_new; + diff_foldcolumn = diff_foldcolumn_new; ++ diff_algorithm = diff_algorithm_new; + + diff_redraw(TRUE); + +*************** +*** 2690,2693 **** +--- 2989,3144 ---- + return n; + } + ++ /* ++ * Handle an ED style diff line. ++ * Return FAIL if the line does not contain diff info. ++ */ ++ static int ++ parse_diff_ed( ++ char_u *line, ++ linenr_T *lnum_orig, ++ long *count_orig, ++ linenr_T *lnum_new, ++ long *count_new) ++ { ++ char_u *p; ++ long f1, l1, f2, l2; ++ int difftype; ++ ++ // The line must be one of three formats: ++ // change: {first}[,{last}]c{first}[,{last}] ++ // append: {first}a{first}[,{last}] ++ // delete: {first}[,{last}]d{first} ++ p = line; ++ f1 = getdigits(&p); ++ if (*p == ',') ++ { ++ ++p; ++ l1 = getdigits(&p); ++ } ++ else ++ l1 = f1; ++ if (*p != 'a' && *p != 'c' && *p != 'd') ++ return FAIL; // invalid diff format ++ difftype = *p++; ++ f2 = getdigits(&p); ++ if (*p == ',') ++ { ++ ++p; ++ l2 = getdigits(&p); ++ } ++ else ++ l2 = f2; ++ if (l1 < f1 || l2 < f2) ++ return FAIL; ++ ++ if (difftype == 'a') ++ { ++ *lnum_orig = f1 + 1; ++ *count_orig = 0; ++ } ++ else ++ { ++ *lnum_orig = f1; ++ *count_orig = l1 - f1 + 1; ++ } ++ if (difftype == 'd') ++ { ++ *lnum_new = f2 + 1; ++ *count_new = 0; ++ } ++ else ++ { ++ *lnum_new = f2; ++ *count_new = l2 - f2 + 1; ++ } ++ return OK; ++ } ++ ++ /* ++ * Parses unified diff with zero(!) context lines. ++ * Return FAIL if there is no diff information in "line". ++ */ ++ static int ++ parse_diff_unified( ++ char_u *line, ++ linenr_T *lnum_orig, ++ long *count_orig, ++ linenr_T *lnum_new, ++ long *count_new) ++ { ++ char_u *p; ++ long oldline, oldcount, newline, newcount; ++ ++ // Parse unified diff hunk header: ++ // @@ -oldline,oldcount +newline,newcount @@ ++ p = line; ++ if (*p++ == '@' && *p++ == '@' && *p++ == ' ' && *p++ == '-') ++ { ++ oldline = getdigits(&p); ++ if (*p == ',') ++ { ++ ++p; ++ oldcount = getdigits(&p); ++ } ++ else ++ oldcount = 1; ++ if (*p++ == ' ' && *p++ == '+') ++ { ++ newline = getdigits(&p); ++ if (*p == ',') ++ { ++ ++p; ++ newcount = getdigits(&p); ++ } ++ else ++ newcount = 1; ++ } ++ else ++ return FAIL; // invalid diff format ++ ++ if (oldcount == 0) ++ oldline += 1; ++ if (newcount == 0) ++ newline += 1; ++ if (newline == 0) ++ newline = 1; ++ ++ *lnum_orig = oldline; ++ *count_orig = oldcount; ++ *lnum_new = newline; ++ *count_new = newcount; ++ ++ return OK; ++ } ++ ++ return FAIL; ++ } ++ ++ /* ++ * Callback function for the xdl_diff() function. ++ * Stores the diff output in a grow array. ++ */ ++ static int ++ xdiff_out(void *priv, mmbuffer_t *mb, int nbuf) ++ { ++ diffout_T *dout = (diffout_T *)priv; ++ int i; ++ char_u *p; ++ ++ for (i = 0; i < nbuf; i++) ++ { ++ // We are only interested in the header lines, skip text lines. ++ if (STRNCMP(mb[i].ptr, "@@ ", 3) != 0) ++ continue; ++ if (ga_grow(&dout->dout_ga, 1) == FAIL) ++ return -1; ++ p = vim_strnsave((char_u *)mb[i].ptr, mb[i].size); ++ if (p == NULL) ++ return -1; ++ ((char_u **)dout->dout_ga.ga_data)[dout->dout_ga.ga_len++] = p; ++ } ++ return 0; ++ } ++ + #endif /* FEAT_DIFF */ +*** ../vim-8.1.0359/src/structs.h 2018-09-06 16:27:20.664831945 +0200 +--- src/structs.h 2018-09-10 17:36:24.457997346 +0200 +*************** +*** 2433,2439 **** + term_T *b_term; /* When not NULL this buffer is for a terminal + * window. */ + #endif +! + }; /* file_buffer */ + + +--- 2433,2441 ---- + term_T *b_term; /* When not NULL this buffer is for a terminal + * window. */ + #endif +! #ifdef FEAT_DIFF +! int b_diff_failed; // internal diff failed for this buffer +! #endif + }; /* file_buffer */ + + +*** ../vim-8.1.0359/src/testdir/dumps/Test_diff_01.dump 2018-09-10 17:44:36.056826154 +0200 +--- src/testdir/dumps/Test_diff_01.dump 2018-09-10 17:36:51.625695584 +0200 +*************** +*** 0 **** +--- 1,20 ---- ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|0+0#0000000#5fd7ff255| @33 ++ | +0#0000e05#a8a8a8255@1|1+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|1+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|2+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|2+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|3+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|3+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|4+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|4+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|5+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|5+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|6+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|6+0#0000000#ffffff0| @33 ++ |++0#0000e05#a8a8a8255| |+|-@1| @1|4| |l|i|n|e|s|:| |7|-@19||+1#0000000#ffffff0|++0#0000e05#a8a8a8255| |+|-@1| @1|4| |l|i|n|e|s|:| |7|-@19 ++ | @1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ |X+3#0000000&|f|i|l|e|1| @12|1|,|1| @11|A|l@1| |X+1&&|f|i|l|e|2| @12|1|,|1| @11|A|l@1 ++ |:+0&&> @73 +*** ../vim-8.1.0359/src/testdir/dumps/Test_diff_02.dump 2018-09-10 17:44:36.060826113 +0200 +--- src/testdir/dumps/Test_diff_02.dump 2018-09-10 17:36:51.625695584 +0200 +*************** +*** 0 **** +--- 1,20 ---- ++ | +0#0000e05#a8a8a8255@1|0+0#0000000#5fd7ff255| @33||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34 ++ | +0#0000e05#a8a8a8255@1|1+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|1+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|2+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|2+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|3+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|3+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|4+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|4+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|5+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|5+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|6+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|6+0#0000000#ffffff0| @33 ++ |++0#0000e05#a8a8a8255| |+|-@1| @1|4| |l|i|n|e|s|:| |7|-@19||+1#0000000#ffffff0|++0#0000e05#a8a8a8255| |+|-@1| @1|4| |l|i|n|e|s|:| |7|-@19 ++ | @1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ |X+3#0000000&|f|i|l|e|1| @12|1|,|1| @11|A|l@1| |X+1&&|f|i|l|e|2| @12|1|,|1| @11|A|l@1 ++ |:+0&&> @73 +*** ../vim-8.1.0359/src/testdir/dumps/Test_diff_03.dump 2018-09-10 17:44:36.064826075 +0200 +--- src/testdir/dumps/Test_diff_03.dump 2018-09-10 17:36:51.625695584 +0200 +*************** +*** 0 **** +--- 1,20 ---- ++ |++0#0000e05#a8a8a8255| |+|-@1| @1|4| |l|i|n|e|s|:| |1|-@19||+1#0000000#ffffff0|++0#0000e05#a8a8a8255| |+|-@1| @1|4| |l|i|n|e|s|:| |1|-@19 ++ | @1|5+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|5+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|6+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|6+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|7+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|7+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|8+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|8+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|9+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|9+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|1+0#0000000#ffffff0|0| @32||+1&&| +0#0000e05#a8a8a8255@1|1+0#0000000#ffffff0|0| @32 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|1+0#0000000#5fd7ff255@1| @32 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ |X+3#0000000&|f|i|l|e|1| @12|1|,|1| @11|A|l@1| |X+1&&|f|i|l|e|2| @12|1|,|1| @11|A|l@1 ++ |:+0&&> @73 +*** ../vim-8.1.0359/src/testdir/dumps/Test_diff_04.dump 2018-09-10 17:44:36.068826034 +0200 +--- src/testdir/dumps/Test_diff_04.dump 2018-09-10 17:36:51.625695584 +0200 +*************** +*** 0 **** +--- 1,20 ---- ++ |++0#0000e05#a8a8a8255| |+|-@1| @1|4| |l|i|n|e|s|:| |1|-@19||+1#0000000#ffffff0|++0#0000e05#a8a8a8255| |+|-@1| @1|4| |l|i|n|e|s|:| |1|-@19 ++ | @1|5+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|5+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|6+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|6+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|7+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|7+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|8+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|8+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|9+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|9+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|1+0#0000000#ffffff0|0| @32||+1&&| +0#0000e05#a8a8a8255@1|1+0#0000000#ffffff0|0| @32 ++ | +0#0000e05#a8a8a8255@1|1+0#0000000#5fd7ff255@1| @32||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ |X+3#0000000&|f|i|l|e|1| @12|1|,|1| @11|A|l@1| |X+1&&|f|i|l|e|2| @12|1|,|1| @11|A|l@1 ++ |:+0&&> @73 +*** ../vim-8.1.0359/src/testdir/dumps/Test_diff_05.dump 2018-09-10 17:44:36.072825994 +0200 +--- src/testdir/dumps/Test_diff_05.dump 2018-09-10 17:36:51.625695584 +0200 +*************** +*** 0 **** +--- 1,20 ---- ++ | +0#0000e05#a8a8a8255@1|1+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|1+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|2+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|2+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|3+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|3+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|4+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|4+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|4+0#0000000#5fd7ff255| @33 ++ | +0#0000e05#a8a8a8255@1|5+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|5+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|6+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|6+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|7+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|7+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|8+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|8+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|9+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|9+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|1+0#0000000#ffffff0|0| @32||+1&&| +0#0000e05#a8a8a8255@1|1+0#0000000#ffffff0|0| @32 ++ | +0#0000e05#a8a8a8255@1|1+0#0000000#5fd7ff255@1| @32||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ |X+3#0000000&|f|i|l|e|1| @12|1|,|1| @11|A|l@1| |X+1&&|f|i|l|e|2| @12|1|,|1| @11|A|l@1 ++ |:+0&&> @73 +*** ../vim-8.1.0359/src/testdir/dumps/Test_diff_06.dump 2018-09-10 17:44:36.072825994 +0200 +--- src/testdir/dumps/Test_diff_06.dump 2018-09-10 17:36:51.625695584 +0200 +*************** +*** 0 **** +--- 1,20 ---- ++ | +0#0000e05#a8a8a8255@1|1+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|1+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|2+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|2+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|3+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|3+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|4+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|4+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|4+0#0000000#5fd7ff255| @33||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34 ++ | +0#0000e05#a8a8a8255@1|5+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|5+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|6+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|6+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|7+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|7+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|8+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|8+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|9+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|9+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|1+0#0000000#ffffff0|0| @32||+1&&| +0#0000e05#a8a8a8255@1|1+0#0000000#ffffff0|0| @32 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|1+0#0000000#5fd7ff255@1| @32 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ |X+3#0000000&|f|i|l|e|1| @12|1|,|1| @11|A|l@1| |X+1&&|f|i|l|e|2| @12|1|,|1| @11|A|l@1 ++ |:+0&&> @73 +*** ../vim-8.1.0359/src/testdir/dumps/Test_diff_07.dump 2018-09-10 17:44:36.076825953 +0200 +--- src/testdir/dumps/Test_diff_07.dump 2018-09-10 17:36:51.625695584 +0200 +*************** +*** 0 **** +--- 1,20 ---- ++ | +0#0000e05#a8a8a8255@1>#+0#0000000#ffffff0|i|n|c|l|u|d|e| |<|s|t|d|i|o|.|h|>| @16||+1&&| +0#0000e05#a8a8a8255@1|#+0#0000000#ffffff0|i|n|c|l|u|d|e| |<|s|t|d|i|o|.|h|>| @16 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@34||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@34 ++ | +0#0000e05#a8a8a8255@1|/+2#0000000#ff404010@1| |F|r|o|b|s| |f|o@1| |h|e|a|r|t|i|l|y| +0&#ffd7ff255@13||+1&#ffffff0| +0#0000e05#a8a8a8255@1|i+2#0000000#ff404010|n|t| |f|i|b|(|i|n|t| |n|)| +0&#ffd7ff255@20 ++ | +0#0000e05#a8a8a8255@1|i+0#0000000#5fd7ff255|n|t| |f|r|o|b|n|i|t|z|(|i|n|t| |f|o@1|)| @13||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34 ++ | +0#0000e05#a8a8a8255@1|{+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|{+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffd7ff255@3|i|n+2&#ff404010|t| |i|;| +0&#ffd7ff255@24||+1&#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#ffd7ff255@3|i|f+2&#ff404010|(|n| |>| |2|)| +0&#ffd7ff255@21 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@3|f|o|r|(|i| |=| |0|;| |i| |<| |1|0|;| |i|+@1|)| @7||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|{| @29||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|{| @29 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffd7ff255@7|p+2&#ff404010|r|i|n|t|f|(|"|Y|o|u|r| |a|n|s|w|e|r| |i|s|:| |"|)+0&#ffd7ff255|;||+1&#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#ffd7ff255@7|r+2&#ff404010|e|t|u|r|n| |f|i|b|(|n|-|1|)| |+| |f|i|b|(|n|-|2|)+0&#ffd7ff255|; ++ | +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@7|p|r|i|n|t|f|(|"|%|d|\|n|"|,| |f|o@1|)|;| @6||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|}| @29||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|}| @29 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@3|r|e|t|u|r|n| |1|;| @21 ++ | +0#0000e05#a8a8a8255@1|}+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|}+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@34||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@34 ++ | +0#0000e05#a8a8a8255@1|i+2#0000000#ff404010|n|t| |f|a|c|t|(|i|n|t| |n|)| +0&#ffd7ff255@19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|/+2#0000000#ff404010@1| |F|r|o|b|s| |f|o@1| |h|e|a|r|t|i|l|y| +0&#ffd7ff255@13 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|i+0#0000000#5fd7ff255|n|t| |f|r|o|b|n|i|t|z|(|i|n|t| |f|o@1|)| @13 ++ | +0#0000e05#a8a8a8255@1|{+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|{+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffd7ff255@3|i|f+2&#ff404010|(|n| |>| |1|)| +0&#ffd7ff255@21||+1&#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#ffd7ff255@3|i|n+2&#ff404010|t| |i|;| +0&#ffd7ff255@24 ++ |X+3&#ffffff0|f|i|l|e|1| @12|1|,|1| @11|T|o|p| |X+1&&|f|i|l|e|2| @12|1|,|1| @11|T|o|p ++ |:+0&&|s|e|t| |d|i|f@1|o|p|t|+|=|i|n|t|e|r|n|a|l| @52 +*** ../vim-8.1.0359/src/testdir/dumps/Test_diff_08.dump 2018-09-10 17:44:36.080825913 +0200 +--- src/testdir/dumps/Test_diff_08.dump 2018-09-10 17:36:51.625695584 +0200 +*************** +*** 0 **** +--- 1,20 ---- ++ | +0#0000e05#a8a8a8255@1>#+0#0000000#ffffff0|i|n|c|l|u|d|e| |<|s|t|d|i|o|.|h|>| @16||+1&&| +0#0000e05#a8a8a8255@1|#+0#0000000#ffffff0|i|n|c|l|u|d|e| |<|s|t|d|i|o|.|h|>| @16 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@34||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@34 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|i+0#0000000#5fd7ff255|n|t| |f|i|b|(|i|n|t| |n|)| @20 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|{+0#0000000#5fd7ff255| @33 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@3|i|f|(|n| |>| |2|)| @21 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@3|{| @29 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@7|r|e|t|u|r|n| |f|i|b|(|n|-|1|)| |+| |f|i|b|(|n|-|2|)|; ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@3|}| @29 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@3|r|e|t|u|r|n| |1|;| @21 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|}+0#0000000#5fd7ff255| @33 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@34 ++ | +0#0000e05#a8a8a8255@1|/+0#0000000#ffffff0@1| |F|r|o|b|s| |f|o@1| |h|e|a|r|t|i|l|y| @13||+1&&| +0#0000e05#a8a8a8255@1|/+0#0000000#ffffff0@1| |F|r|o|b|s| |f|o@1| |h|e|a|r|t|i|l|y| @13 ++ | +0#0000e05#a8a8a8255@1|i+0#0000000#ffffff0|n|t| |f|r|o|b|n|i|t|z|(|i|n|t| |f|o@1|)| @13||+1&&| +0#0000e05#a8a8a8255@1|i+0#0000000#ffffff0|n|t| |f|r|o|b|n|i|t|z|(|i|n|t| |f|o@1|)| @13 ++ | +0#0000e05#a8a8a8255@1|{+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|{+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|i|n|t| |i|;| @24||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|i|n|t| |i|;| @24 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|f|o|r|(|i| |=| |0|;| |i| |<| |1|0|;| |i|+@1|)| @7||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|f|o|r|(|i| |=| |0|;| |i| |<| |1|0|;| |i|+@1|)| @7 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|{| @29||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|{| @29 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@7|p|r|i|n|t|f|(|"|Y|o|u|r| |a|n|s|w|e|r| |i|s|:| |"|)|;||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34 ++ |X+3#0000000#ffffff0|f|i|l|e|1| @12|1|,|1| @11|T|o|p| |X+1&&|f|i|l|e|2| @12|1|,|1| @11|T|o|p ++ |:+0&&|s|e|t| |d|i|f@1|o|p|t|+|=|a|l|g|o|r|i|t|h|m|:|p|a|t|i|e|n|c|e| @42 +*** ../vim-8.1.0359/src/testdir/dumps/Test_diff_09.dump 2018-09-10 17:44:36.084825872 +0200 +--- src/testdir/dumps/Test_diff_09.dump 2018-09-10 17:36:51.625695584 +0200 +*************** +*** 0 **** +--- 1,20 ---- ++ | +0#0000e05#a8a8a8255@1>#+0#0000000#ffffff0|i|n|c|l|u|d|e| |<|s|t|d|i|o|.|h|>| @16||+1&&| +0#0000e05#a8a8a8255@1|#+0#0000000#ffffff0|i|n|c|l|u|d|e| |<|s|t|d|i|o|.|h|>| @16 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@34||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@34 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|i+0#0000000#5fd7ff255|n|t| |f|i|b|(|i|n|t| |n|)| @20 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|{+0#0000000#5fd7ff255| @33 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@3|i|f|(|n| |>| |2|)| @21 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@3|{| @29 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@7|r|e|t|u|r|n| |f|i|b|(|n|-|1|)| |+| |f|i|b|(|n|-|2|)|; ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@3|}| @29 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@3|r|e|t|u|r|n| |1|;| @21 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|}+0#0000000#5fd7ff255| @33 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@34 ++ | +0#0000e05#a8a8a8255@1|/+0#0000000#ffffff0@1| |F|r|o|b|s| |f|o@1| |h|e|a|r|t|i|l|y| @13||+1&&| +0#0000e05#a8a8a8255@1|/+0#0000000#ffffff0@1| |F|r|o|b|s| |f|o@1| |h|e|a|r|t|i|l|y| @13 ++ | +0#0000e05#a8a8a8255@1|i+0#0000000#ffffff0|n|t| |f|r|o|b|n|i|t|z|(|i|n|t| |f|o@1|)| @13||+1&&| +0#0000e05#a8a8a8255@1|i+0#0000000#ffffff0|n|t| |f|r|o|b|n|i|t|z|(|i|n|t| |f|o@1|)| @13 ++ | +0#0000e05#a8a8a8255@1|{+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|{+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|i|n|t| |i|;| @24||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|i|n|t| |i|;| @24 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|f|o|r|(|i| |=| |0|;| |i| |<| |1|0|;| |i|+@1|)| @7||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|f|o|r|(|i| |=| |0|;| |i| |<| |1|0|;| |i|+@1|)| @7 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|{| @29||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|{| @29 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@7|p|r|i|n|t|f|(|"|Y|o|u|r| |a|n|s|w|e|r| |i|s|:| |"|)|;||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34 ++ |X+3#0000000#ffffff0|f|i|l|e|1| @12|1|,|1| @11|T|o|p| |X+1&&|f|i|l|e|2| @12|1|,|1| @11|T|o|p ++ |:+0&&|s|e|t| |d|i|f@1|o|p|t|+|=|a|l|g|o|r|i|t|h|m|:|p|a|t|i|e|n|c|e| @42 +*** ../vim-8.1.0359/src/testdir/dumps/Test_diff_10.dump 2018-09-10 17:44:36.088825834 +0200 +--- src/testdir/dumps/Test_diff_10.dump 2018-09-10 17:36:51.625695584 +0200 +*************** +*** 0 **** +--- 1,20 ---- ++ | +0#0000e05#a8a8a8255@1> +0#0000000#ffffff0@34||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@34 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@1|d|e|f| |f|i|n|a|l|i|z|e|(|v|a|l|u|e|s|)| @12||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@1|d|e|f| |f|i|n|a|l|i|z|e|(|v|a|l|u|e|s|)| @12 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@34||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@34 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|v|a|l|u|e|s|.|e|a|c|h| |d|o| |||v||| @12||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|v|a|l|u|e|s|.|e|a|c|h| |d|o| |||v||| @12 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@5|v|.|p|r|e|p|a|r|e| @19 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@3|e|n|d| @27 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@34 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@3|v|a|l|u|e|s|.|e|a|c|h| |d|o| |||v||| @12 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@5|v|.|f|i|n|a|l|i|z|e| @18||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@5|v|.|f|i|n|a|l|i|z|e| @18 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|e|n|d| @27||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|e|n|d| @27 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ |X+3#0000000&|f|i|l|e|1| @12|1|,|0|-|1| @9|A|l@1| |X+1&&|f|i|l|e|2| @12|1|,|0|-|1| @9|A|l@1 ++ |:+0&&|s|e|t| |d|i|f@1|o|p|t|+|=|i|n|t|e|r|n|a|l| @52 +*** ../vim-8.1.0359/src/testdir/dumps/Test_diff_11.dump 2018-09-10 17:44:36.092825793 +0200 +--- src/testdir/dumps/Test_diff_11.dump 2018-09-10 17:36:51.625695584 +0200 +*************** +*** 0 **** +--- 1,20 ---- ++ | +0#0000e05#a8a8a8255@1> +0#0000000#ffffff0@34||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@34 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@1|d|e|f| |f|i|n|a|l|i|z|e|(|v|a|l|u|e|s|)| @12||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@1|d|e|f| |f|i|n|a|l|i|z|e|(|v|a|l|u|e|s|)| @12 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@34||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@34 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@3|v|a|l|u|e|s|.|e|a|c|h| |d|o| |||v||| @12 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@5|v|.|p|r|e|p|a|r|e| @19 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@3|e|n|d| @27 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@34 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|v|a|l|u|e|s|.|e|a|c|h| |d|o| |||v||| @12||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|v|a|l|u|e|s|.|e|a|c|h| |d|o| |||v||| @12 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@5|v|.|f|i|n|a|l|i|z|e| @18||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@5|v|.|f|i|n|a|l|i|z|e| @18 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|e|n|d| @27||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@3|e|n|d| @27 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ |X+3#0000000&|f|i|l|e|1| @12|1|,|0|-|1| @9|A|l@1| |X+1&&|f|i|l|e|2| @12|1|,|0|-|1| @9|A|l@1 ++ |:+0&&|s|e|t| |d|i|f@1|o|p|t|+|=|i|n|d|e|n|t|-|h|e|u|r|i|s|t|i|c| @44 +*** ../vim-8.1.0359/src/testdir/dumps/Test_diff_12.dump 2018-09-10 17:44:36.096825753 +0200 +--- src/testdir/dumps/Test_diff_12.dump 2018-09-10 17:36:51.625695584 +0200 +*************** +*** 0 **** +--- 1,20 ---- ++ |++0#0000e05#a8a8a8255| |+|-@1| |1|0| |l|i|n|e|s|:| |1|-@19||+1#0000000#ffffff0|++0#0000e05#a8a8a8255| |+|-@1| |1|0| |l|i|n|e|s|:| |1|-@19 ++ | @1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ |X+3#0000000&|f|i|l|e|1| @12|1|,|1| @11|A|l@1| |X+1&&|f|i|l|e|2| @12|1|,|1| @11|A|l@1 ++ |:+0&&> @73 +*** ../vim-8.1.0359/src/testdir/dumps/Test_diff_13.dump 2018-09-10 17:44:36.096825753 +0200 +--- src/testdir/dumps/Test_diff_13.dump 2018-09-10 17:36:51.625695584 +0200 +*************** +*** 0 **** +--- 1,20 ---- ++ |-+0#0000e05#a8a8a8255| | +0#0000000#ffffff0@34||+1&&|-+0#0000e05#a8a8a8255| | +0#0000000#ffffff0@34 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ |X+3#0000000&|f|i|l|e|1| @12|0|,|0|-|1| @9|A|l@1| |X+1&&|f|i|l|e|2| @12|0|,|0|-|1| @9|A|l@1 ++ |:+0&&> @73 +*** ../vim-8.1.0359/src/testdir/dumps/Test_diff_14.dump 2018-09-10 17:44:36.100825712 +0200 +--- src/testdir/dumps/Test_diff_14.dump 2018-09-10 17:36:51.625695584 +0200 +*************** +*** 0 **** +--- 1,20 ---- ++ | +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|A+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|b+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|b+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|c+0#0000000#ffd7ff255|d| @32||+1&#ffffff0| +0#0000e05#a8a8a8255@1|c+0#0000000#ffd7ff255|D|e+2&#ff404010| +0&#ffd7ff255@31 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ |X+3#0000000&|f|i|l|e|1| @12|1|,|1| @11|A|l@1| |X+1&&|f|i|l|e|2| @12|1|,|1| @11|A|l@1 ++ |:+0&&> @73 +*** ../vim-8.1.0359/src/testdir/dumps/Test_diff_15.dump 2018-09-10 17:44:36.104825672 +0200 +--- src/testdir/dumps/Test_diff_15.dump 2018-09-10 17:36:51.625695584 +0200 +*************** +*** 0 **** +--- 1,20 ---- ++ | +0#0000e05#a8a8a8255@1>i+0#0000000#ffffff0|n|t| |m|a|i|n|(|)| @24||+1&&| +0#0000e05#a8a8a8255@1|i+0#0000000#ffffff0|n|t| |m|a|i|n|(|)| @24 ++ | +0#0000e05#a8a8a8255@1|{+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|{+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@2|i|f| |(|0|)| @25 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@2|{| @30 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@2|p|r|i|n|t|f|(|"|H|e|l@1|o|,| |W|o|r|l|d|!|"|)|;| @7||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@5|p|r|i|n|t|f|(|"|H|e|l@1|o|,| |W|o|r|l|d|!|"|)|;| @4 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@2|r|e|t|u|r|n| |0|;| @22||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@5|r|e|t|u|r|n| |0|;| @19 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@2|}| @30 ++ | +0#0000e05#a8a8a8255@1|}+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|}+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ |X+3#0000000&|f|i|l|e|1| @12|1|,|1| @11|A|l@1| |X+1&&|f|i|l|e|2| @12|1|,|1| @11|A|l@1 ++ |:+0&&|s|e|t| |d|i|f@1|o|p|t|&|v|i|m| |d|i|f@1|o|p|t|+|=|f|i|l@1|e|r| |d|i|f@1|o|p|t|+|=|i|w|h|i|t|e| @26 +*** ../vim-8.1.0359/src/testdir/dumps/Test_diff_16.dump 2018-09-10 17:44:36.108825631 +0200 +--- src/testdir/dumps/Test_diff_16.dump 2018-09-10 17:36:51.625695584 +0200 +*************** +*** 0 **** +--- 1,20 ---- ++ | +0#0000e05#a8a8a8255@1>i+0#0000000#ffffff0|n|t| |m|a|i|n|(|)| @24||+1&&| +0#0000e05#a8a8a8255@1|i+0#0000000#ffffff0|n|t| |m|a|i|n|(|)| @24 ++ | +0#0000e05#a8a8a8255@1|{+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|{+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@2|i|f| |(|0|)| @25 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@2|{| @30 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@2|p|r|i|n|t|f|(|"|H|e|l@1|o|,| |W|o|r|l|d|!|"|)|;| @7||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@5|p|r|i|n|t|f|(|"|H|e|l@1|o|,| |W|o|r|l|d|!|"|)|;| @4 ++ | +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@2|r|e|t|u|r|n| |0|;| @22||+1&&| +0#0000e05#a8a8a8255@1| +0#0000000#ffffff0@5|r|e|t|u|r|n| |0|;| @19 ++ | +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1| +0#0000000#5fd7ff255@2|}| @30 ++ | +0#0000e05#a8a8a8255@1|}+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|}+0#0000000#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ | +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33||+1#0000000&| +0#0000e05#a8a8a8255@1|~+0#4040ff13#ffffff0| @33 ++ |X+3#0000000&|f|i|l|e|1| @12|1|,|1| @11|A|l@1| |X+1&&|f|i|l|e|2| @12|1|,|1| @11|A|l@1 ++ |:+0&&|s|e|t| |d|i|f@1|o|p|t|+|=|i|n|t|e|r|n|a|l| @52 +*** ../vim-8.1.0359/src/testdir/test_diffmode.vim 2017-12-01 20:25:59.000000000 +0100 +--- src/testdir/test_diffmode.vim 2018-09-10 17:38:33.584583735 +0200 +*************** +*** 1,4 **** +--- 1,6 ---- + " Tests for diff mode ++ source shared.vim ++ source screendump.vim + + func Test_diff_fold_sync() + enew! +*************** +*** 33,38 **** +--- 35,52 ---- + endfunc + + func Test_vert_split() ++ set diffopt=filler ++ call Common_vert_split() ++ set diffopt& ++ endfunc ++ ++ func Test_vert_split_internal() ++ set diffopt=internal,filler ++ call Common_vert_split() ++ set diffopt& ++ endfunc ++ ++ func Common_vert_split() + " Disable the title to avoid xterm keeping the wrong one. + set notitle noicon + new +*************** +*** 275,284 **** + bwipe! + endfunc + +! func Test_diffopt_icase() +! set diffopt=icase,foldcolumn:0 +! +! e one + call setline(1, ['One', 'Two', 'Three', 'Four', 'Fi#ve']) + redraw + let normattr = screenattr(1, 1) +--- 295,302 ---- + bwipe! + endfunc + +! func Common_icase_test() +! edit one + call setline(1, ['One', 'Two', 'Three', 'Four', 'Fi#ve']) + redraw + let normattr = screenattr(1, 1) +*************** +*** 300,331 **** + + diffoff! + %bwipe! + set diffopt& + endfunc + +! func Test_diffopt_iwhite() +! set diffopt=iwhite,foldcolumn:0 + +! e one +! " Difference in trailing spaces should be ignored, + " but not other space differences. +! call setline(1, ["One \t", 'Two', 'Three', 'Four']) + redraw + let normattr = screenattr(1, 1) + diffthis + + botright vert new two +! call setline(1, ["One\t ", "Two\t ", 'Three', ' Four']) + diffthis + + redraw + call assert_equal(normattr, screenattr(1, 1)) + call assert_equal(normattr, screenattr(2, 1)) + call assert_equal(normattr, screenattr(3, 1)) +! call assert_notequal(normattr, screenattr(4, 1)) + + diffoff! + %bwipe! + set diffopt& + endfunc + +--- 318,371 ---- + + diffoff! + %bwipe! ++ endfunc ++ ++ func Test_diffopt_icase() ++ set diffopt=icase,foldcolumn:0 ++ call Common_icase_test() + set diffopt& + endfunc + +! func Test_diffopt_icase_internal() +! set diffopt=icase,foldcolumn:0,internal +! call Common_icase_test() +! set diffopt& +! endfunc + +! func Common_iwhite_test() +! edit one +! " Difference in trailing spaces and amount of spaces should be ignored, + " but not other space differences. +! call setline(1, ["One \t", 'Two', 'Three', 'one two', 'one two', 'Four']) + redraw + let normattr = screenattr(1, 1) + diffthis + + botright vert new two +! call setline(1, ["One\t ", "Two\t ", 'Three', 'one two', 'onetwo', ' Four']) + diffthis + + redraw + call assert_equal(normattr, screenattr(1, 1)) + call assert_equal(normattr, screenattr(2, 1)) + call assert_equal(normattr, screenattr(3, 1)) +! call assert_equal(normattr, screenattr(4, 1)) +! call assert_notequal(normattr, screenattr(5, 1)) +! call assert_notequal(normattr, screenattr(6, 1)) + + diffoff! + %bwipe! ++ endfunc ++ ++ func Test_diffopt_iwhite() ++ set diffopt=iwhite,foldcolumn:0 ++ call Common_iwhite_test() ++ set diffopt& ++ endfunc ++ ++ func Test_diffopt_iwhite_internal() ++ set diffopt=internal,iwhite,foldcolumn:0 ++ call Common_iwhite_test() + set diffopt& + endfunc + +*************** +*** 339,346 **** +--- 379,391 ---- + + set diffopt=context:2 + call assert_equal('+-- 2 lines: 1', foldtextresult(1)) ++ set diffopt=internal,context:2 ++ call assert_equal('+-- 2 lines: 1', foldtextresult(1)) ++ + set diffopt=context:1 + call assert_equal('+-- 3 lines: 1', foldtextresult(1)) ++ set diffopt=internal,context:1 ++ call assert_equal('+-- 3 lines: 1', foldtextresult(1)) + + diffoff! + %bwipe! +*************** +*** 348,354 **** + endfunc + + func Test_diffopt_horizontal() +! set diffopt=horizontal + diffsplit + + call assert_equal(&columns, winwidth(1)) +--- 393,399 ---- + endfunc + + func Test_diffopt_horizontal() +! set diffopt=internal,horizontal + diffsplit + + call assert_equal(&columns, winwidth(1)) +*************** +*** 362,368 **** + endfunc + + func Test_diffopt_vertical() +! set diffopt=vertical + diffsplit + + call assert_equal(&lines - 2, winheight(1)) +--- 407,413 ---- + endfunc + + func Test_diffopt_vertical() +! set diffopt=internal,vertical + diffsplit + + call assert_equal(&lines - 2, winheight(1)) +*************** +*** 376,382 **** + endfunc + + func Test_diffopt_hiddenoff() +! set diffopt=filler,foldcolumn:0,hiddenoff + e! one + call setline(1, ['Two', 'Three']) + redraw +--- 421,427 ---- + endfunc + + func Test_diffopt_hiddenoff() +! set diffopt=internal,filler,foldcolumn:0,hiddenoff + e! one + call setline(1, ['Two', 'Three']) + redraw +*************** +*** 399,405 **** + endfunc + + func Test_diffoff_hidden() +! set diffopt=filler,foldcolumn:0 + e! one + call setline(1, ['Two', 'Three']) + redraw +--- 444,450 ---- + endfunc + + func Test_diffoff_hidden() +! set diffopt=internal,filler,foldcolumn:0 + e! one + call setline(1, ['Two', 'Three']) + redraw +*************** +*** 629,631 **** +--- 674,791 ---- + bwipe! + bwipe! + endfunc ++ ++ func WriteDiffFiles(list1, list2) ++ call writefile(a:list1, 'Xfile1') ++ call writefile(a:list2, 'Xfile2') ++ endfunc ++ ++ " Verify a screendump with both the external and external diff. ++ func VerifyBoth(buf, dumpfile, extra) ++ call term_sendkeys(a:buf, ":diffupdate!\<cr>") ++ " trailing : for leaving the cursor on the command line ++ for cmd in [":set diffopt=filler" . a:extra . "\<cr>:", ":set diffopt+=internal\<cr>:"] ++ call term_sendkeys(a:buf, cmd) ++ if VerifyScreenDump(a:buf, a:dumpfile, {}, cmd =~ 'internal' ? 'internal' : 'external') ++ break " don't let the next iteration overwrite the "failed" file. ++ endif ++ endfor ++ endfunc ++ ++ func Test_diff_screen() ++ if !CanRunVimInTerminal() || !has('menu') ++ return ++ endif ++ " clean up already existing swap files, just in case ++ call delete('.Xfile1.swp') ++ call delete('.Xfile2.swp') ++ ++ " Test 1: Add a line in beginning of file 2 ++ call WriteDiffFiles([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) ++ let buf = RunVimInTerminal('-d Xfile1 Xfile2', {}) ++ " Set autoread mode, ,so that Vim won't complain once we re-write the test ++ " files ++ call term_sendkeys(buf, ":set autoread\<cr>\<c-w>w:set autoread\<cr>\<c-w>w") ++ ++ call VerifyBoth(buf, 'Test_diff_01', '') ++ ++ " Test 2: Add a line in beginning of file 1 ++ call WriteDiffFiles([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) ++ call VerifyBoth(buf, 'Test_diff_02', '') ++ ++ " Test 3: Add a line at the end of file 2 ++ call WriteDiffFiles([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) ++ call VerifyBoth(buf, 'Test_diff_03', '') ++ ++ " Test 4: Add a line at the end of file 1 ++ call WriteDiffFiles([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) ++ call VerifyBoth(buf, 'Test_diff_04', '') ++ ++ " Test 5: Add a line in the middle of file 2, remove on at the end of file 1 ++ call WriteDiffFiles([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], [1, 2, 3, 4, 4, 5, 6, 7, 8, 9, 10]) ++ call VerifyBoth(buf, 'Test_diff_05', '') ++ ++ " Test 6: Add a line in the middle of file 1, remove on at the end of file 2 ++ call WriteDiffFiles([1, 2, 3, 4, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) ++ call VerifyBoth(buf, 'Test_diff_06', '') ++ ++ " Test 7 - 9: Test normal/patience/histogram diff algorithm ++ call WriteDiffFiles(['#include <stdio.h>', '', '// Frobs foo heartily', 'int frobnitz(int foo)', '{', ++ \ ' int i;', ' for(i = 0; i < 10; i++)', ' {', ' printf("Your answer is: ");', ++ \ ' printf("%d\n", foo);', ' }', '}', '', 'int fact(int n)', '{', ' if(n > 1)', ' {', ++ \ ' return fact(n-1) * n;', ' }', ' return 1;', '}', '', 'int main(int argc, char **argv)', ++ \ '{', ' frobnitz(fact(10));', '}'], ++ \ ['#include <stdio.h>', '', 'int fib(int n)', '{', ' if(n > 2)', ' {', ++ \ ' return fib(n-1) + fib(n-2);', ' }', ' return 1;', '}', '', '// Frobs foo heartily', ++ \ 'int frobnitz(int foo)', '{', ' int i;', ' for(i = 0; i < 10; i++)', ' {', ++ \ ' printf("%d\n", foo);', ' }', '}', '', ++ \ 'int main(int argc, char **argv)', '{', ' frobnitz(fib(10));', '}']) ++ call term_sendkeys(buf, ":diffupdate!\<cr>") ++ call term_sendkeys(buf, ":set diffopt+=internal\<cr>") ++ call VerifyScreenDump(buf, 'Test_diff_07', {}) ++ ++ call term_sendkeys(buf, ":set diffopt+=algorithm:patience\<cr>") ++ call VerifyScreenDump(buf, 'Test_diff_08', {}) ++ ++ call term_sendkeys(buf, ":set diffopt+=algorithm:histogram\<cr>") ++ call VerifyScreenDump(buf, 'Test_diff_09', {}) ++ ++ " Test 10-11: normal/indent-heuristic ++ call term_sendkeys(buf, ":set diffopt&vim\<cr>") ++ call WriteDiffFiles(['', ' def finalize(values)', '', ' values.each do |v|', ' v.finalize', ' end'], ++ \ ['', ' def finalize(values)', '', ' values.each do |v|', ' v.prepare', ' end', '', ++ \ ' values.each do |v|', ' v.finalize', ' end']) ++ call term_sendkeys(buf, ":diffupdate!\<cr>") ++ call term_sendkeys(buf, ":set diffopt+=internal\<cr>") ++ call VerifyScreenDump(buf, 'Test_diff_10', {}) ++ ++ call term_sendkeys(buf, ":set diffopt+=indent-heuristic\<cr>") ++ call VerifyScreenDump(buf, 'Test_diff_11', {}) ++ ++ " Test 12: diff the same file ++ call WriteDiffFiles([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) ++ call VerifyBoth(buf, 'Test_diff_12', '') ++ ++ " Test 13: diff an empty file ++ call WriteDiffFiles([], []) ++ call VerifyBoth(buf, 'Test_diff_13', '') ++ ++ " Test 14: test diffopt+=icase ++ call WriteDiffFiles(['a', 'b', 'cd'], ['A', 'b', 'cDe']) ++ call VerifyBoth(buf, 'Test_diff_14', " diffopt+=filler diffopt+=icase") ++ ++ " Test 15-16: test diffopt+=iwhite ++ call WriteDiffFiles(['int main()', '{', ' printf("Hello, World!");', ' return 0;', '}'], ++ \ ['int main()', '{', ' if (0)', ' {', ' printf("Hello, World!");', ' return 0;', ' }', '}']) ++ call term_sendkeys(buf, ":diffupdate!\<cr>") ++ call term_sendkeys(buf, ":set diffopt&vim diffopt+=filler diffopt+=iwhite\<cr>") ++ call VerifyScreenDump(buf, 'Test_diff_15', {}) ++ call term_sendkeys(buf, ":set diffopt+=internal\<cr>") ++ call VerifyScreenDump(buf, 'Test_diff_16', {}) ++ ++ " clean up ++ call StopVimInTerminal(buf) ++ call delete('Xfile1') ++ call delete('Xfile2') ++ endfunc ++ +*** ../vim-8.1.0359/src/xdiff/COPYING 1970-01-01 01:00:00.000000000 +0100 +--- src/xdiff/COPYING 2018-09-10 17:39:20.324083781 +0200 +*************** +*** 0 **** +--- 1,504 ---- ++ GNU LESSER GENERAL PUBLIC LICENSE ++ Version 2.1, February 1999 ++ ++ Copyright (C) 1991, 1999 Free Software Foundation, Inc. ++ 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ Everyone is permitted to copy and distribute verbatim copies ++ of this license document, but changing it is not allowed. ++ ++ [This is the first released version of the Lesser GPL. It also counts ++ as the successor of the GNU Library Public License, version 2, hence ++ the version number 2.1.] ++ ++ Preamble ++ ++ The licenses for most software are designed to take away your ++ freedom to share and change it. By contrast, the GNU General Public ++ Licenses are intended to guarantee your freedom to share and change ++ free software--to make sure the software is free for all its users. ++ ++ This license, the Lesser General Public License, applies to some ++ specially designated software packages--typically libraries--of the ++ Free Software Foundation and other authors who decide to use it. You ++ can use it too, but we suggest you first think carefully about whether ++ this license or the ordinary General Public License is the better ++ strategy to use in any particular case, based on the explanations below. ++ ++ When we speak of free software, we are referring to freedom of use, ++ not price. Our General Public Licenses are designed to make sure that ++ you have the freedom to distribute copies of free software (and charge ++ for this service if you wish); that you receive source code or can get ++ it if you want it; that you can change the software and use pieces of ++ it in new free programs; and that you are informed that you can do ++ these things. ++ ++ To protect your rights, we need to make restrictions that forbid ++ distributors to deny you these rights or to ask you to surrender these ++ rights. These restrictions translate to certain responsibilities for ++ you if you distribute copies of the library or if you modify it. ++ ++ For example, if you distribute copies of the library, whether gratis ++ or for a fee, you must give the recipients all the rights that we gave ++ you. You must make sure that they, too, receive or can get the source ++ code. If you link other code with the library, you must provide ++ complete object files to the recipients, so that they can relink them ++ with the library after making changes to the library and recompiling ++ it. And you must show them these terms so they know their rights. ++ ++ We protect your rights with a two-step method: (1) we copyright the ++ library, and (2) we offer you this license, which gives you legal ++ permission to copy, distribute and/or modify the library. ++ ++ To protect each distributor, we want to make it very clear that ++ there is no warranty for the free library. Also, if the library is ++ modified by someone else and passed on, the recipients should know ++ that what they have is not the original version, so that the original ++ author's reputation will not be affected by problems that might be ++ introduced by others. ++ ++ Finally, software patents pose a constant threat to the existence of ++ any free program. We wish to make sure that a company cannot ++ effectively restrict the users of a free program by obtaining a ++ restrictive license from a patent holder. Therefore, we insist that ++ any patent license obtained for a version of the library must be ++ consistent with the full freedom of use specified in this license. ++ ++ Most GNU software, including some libraries, is covered by the ++ ordinary GNU General Public License. This license, the GNU Lesser ++ General Public License, applies to certain designated libraries, and ++ is quite different from the ordinary General Public License. We use ++ this license for certain libraries in order to permit linking those ++ libraries into non-free programs. ++ ++ When a program is linked with a library, whether statically or using ++ a shared library, the combination of the two is legally speaking a ++ combined work, a derivative of the original library. The ordinary ++ General Public License therefore permits such linking only if the ++ entire combination fits its criteria of freedom. The Lesser General ++ Public License permits more lax criteria for linking other code with ++ the library. ++ ++ We call this license the "Lesser" General Public License because it ++ does Less to protect the user's freedom than the ordinary General ++ Public License. It also provides other free software developers Less ++ of an advantage over competing non-free programs. These disadvantages ++ are the reason we use the ordinary General Public License for many ++ libraries. However, the Lesser license provides advantages in certain ++ special circumstances. ++ ++ For example, on rare occasions, there may be a special need to ++ encourage the widest possible use of a certain library, so that it becomes ++ a de-facto standard. To achieve this, non-free programs must be ++ allowed to use the library. A more frequent case is that a free ++ library does the same job as widely used non-free libraries. In this ++ case, there is little to gain by limiting the free library to free ++ software only, so we use the Lesser General Public License. ++ ++ In other cases, permission to use a particular library in non-free ++ programs enables a greater number of people to use a large body of ++ free software. For example, permission to use the GNU C Library in ++ non-free programs enables many more people to use the whole GNU ++ operating system, as well as its variant, the GNU/Linux operating ++ system. ++ ++ Although the Lesser General Public License is Less protective of the ++ users' freedom, it does ensure that the user of a program that is ++ linked with the Library has the freedom and the wherewithal to run ++ that program using a modified version of the Library. ++ ++ The precise terms and conditions for copying, distribution and ++ modification follow. Pay close attention to the difference between a ++ "work based on the library" and a "work that uses the library". The ++ former contains code derived from the library, whereas the latter must ++ be combined with the library in order to run. ++ ++ GNU LESSER GENERAL PUBLIC LICENSE ++ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION ++ ++ 0. This License Agreement applies to any software library or other ++ program which contains a notice placed by the copyright holder or ++ other authorized party saying it may be distributed under the terms of ++ this Lesser General Public License (also called "this License"). ++ Each licensee is addressed as "you". ++ ++ A "library" means a collection of software functions and/or data ++ prepared so as to be conveniently linked with application programs ++ (which use some of those functions and data) to form executables. ++ ++ The "Library", below, refers to any such software library or work ++ which has been distributed under these terms. A "work based on the ++ Library" means either the Library or any derivative work under ++ copyright law: that is to say, a work containing the Library or a ++ portion of it, either verbatim or with modifications and/or translated ++ straightforwardly into another language. (Hereinafter, translation is ++ included without limitation in the term "modification".) ++ ++ "Source code" for a work means the preferred form of the work for ++ making modifications to it. For a library, complete source code means ++ all the source code for all modules it contains, plus any associated ++ interface definition files, plus the scripts used to control compilation ++ and installation of the library. ++ ++ Activities other than copying, distribution and modification are not ++ covered by this License; they are outside its scope. The act of ++ running a program using the Library is not restricted, and output from ++ such a program is covered only if its contents constitute a work based ++ on the Library (independent of the use of the Library in a tool for ++ writing it). Whether that is true depends on what the Library does ++ and what the program that uses the Library does. ++ ++ 1. You may copy and distribute verbatim copies of the Library's ++ complete source code as you receive it, in any medium, provided that ++ you conspicuously and appropriately publish on each copy an ++ appropriate copyright notice and disclaimer of warranty; keep intact ++ all the notices that refer to this License and to the absence of any ++ warranty; and distribute a copy of this License along with the ++ Library. ++ ++ You may charge a fee for the physical act of transferring a copy, ++ and you may at your option offer warranty protection in exchange for a ++ fee. ++ ++ 2. You may modify your copy or copies of the Library or any portion ++ of it, thus forming a work based on the Library, and copy and ++ distribute such modifications or work under the terms of Section 1 ++ above, provided that you also meet all of these conditions: ++ ++ a) The modified work must itself be a software library. ++ ++ b) You must cause the files modified to carry prominent notices ++ stating that you changed the files and the date of any change. ++ ++ c) You must cause the whole of the work to be licensed at no ++ charge to all third parties under the terms of this License. ++ ++ d) If a facility in the modified Library refers to a function or a ++ table of data to be supplied by an application program that uses ++ the facility, other than as an argument passed when the facility ++ is invoked, then you must make a good faith effort to ensure that, ++ in the event an application does not supply such function or ++ table, the facility still operates, and performs whatever part of ++ its purpose remains meaningful. ++ ++ (For example, a function in a library to compute square roots has ++ a purpose that is entirely well-defined independent of the ++ application. Therefore, Subsection 2d requires that any ++ application-supplied function or table used by this function must ++ be optional: if the application does not supply it, the square ++ root function must still compute square roots.) ++ ++ These requirements apply to the modified work as a whole. If ++ identifiable sections of that work are not derived from the Library, ++ and can be reasonably considered independent and separate works in ++ themselves, then this License, and its terms, do not apply to those ++ sections when you distribute them as separate works. But when you ++ distribute the same sections as part of a whole which is a work based ++ on the Library, the distribution of the whole must be on the terms of ++ this License, whose permissions for other licensees extend to the ++ entire whole, and thus to each and every part regardless of who wrote ++ it. ++ ++ Thus, it is not the intent of this section to claim rights or contest ++ your rights to work written entirely by you; rather, the intent is to ++ exercise the right to control the distribution of derivative or ++ collective works based on the Library. ++ ++ In addition, mere aggregation of another work not based on the Library ++ with the Library (or with a work based on the Library) on a volume of ++ a storage or distribution medium does not bring the other work under ++ the scope of this License. ++ ++ 3. You may opt to apply the terms of the ordinary GNU General Public ++ License instead of this License to a given copy of the Library. To do ++ this, you must alter all the notices that refer to this License, so ++ that they refer to the ordinary GNU General Public License, version 2, ++ instead of to this License. (If a newer version than version 2 of the ++ ordinary GNU General Public License has appeared, then you can specify ++ that version instead if you wish.) Do not make any other change in ++ these notices. ++ ++ Once this change is made in a given copy, it is irreversible for ++ that copy, so the ordinary GNU General Public License applies to all ++ subsequent copies and derivative works made from that copy. ++ ++ This option is useful when you wish to copy part of the code of ++ the Library into a program that is not a library. ++ ++ 4. You may copy and distribute the Library (or a portion or ++ derivative of it, under Section 2) in object code or executable form ++ under the terms of Sections 1 and 2 above provided that you accompany ++ it with the complete corresponding machine-readable source code, which ++ must be distributed under the terms of Sections 1 and 2 above on a ++ medium customarily used for software interchange. ++ ++ If distribution of object code is made by offering access to copy ++ from a designated place, then offering equivalent access to copy the ++ source code from the same place satisfies the requirement to ++ distribute the source code, even though third parties are not ++ compelled to copy the source along with the object code. ++ ++ 5. A program that contains no derivative of any portion of the ++ Library, but is designed to work with the Library by being compiled or ++ linked with it, is called a "work that uses the Library". Such a ++ work, in isolation, is not a derivative work of the Library, and ++ therefore falls outside the scope of this License. ++ ++ However, linking a "work that uses the Library" with the Library ++ creates an executable that is a derivative of the Library (because it ++ contains portions of the Library), rather than a "work that uses the ++ library". The executable is therefore covered by this License. ++ Section 6 states terms for distribution of such executables. ++ ++ When a "work that uses the Library" uses material from a header file ++ that is part of the Library, the object code for the work may be a ++ derivative work of the Library even though the source code is not. ++ Whether this is true is especially significant if the work can be ++ linked without the Library, or if the work is itself a library. The ++ threshold for this to be true is not precisely defined by law. ++ ++ If such an object file uses only numerical parameters, data ++ structure layouts and accessors, and small macros and small inline ++ functions (ten lines or less in length), then the use of the object ++ file is unrestricted, regardless of whether it is legally a derivative ++ work. (Executables containing this object code plus portions of the ++ Library will still fall under Section 6.) ++ ++ Otherwise, if the work is a derivative of the Library, you may ++ distribute the object code for the work under the terms of Section 6. ++ Any executables containing that work also fall under Section 6, ++ whether or not they are linked directly with the Library itself. ++ ++ 6. As an exception to the Sections above, you may also combine or ++ link a "work that uses the Library" with the Library to produce a ++ work containing portions of the Library, and distribute that work ++ under terms of your choice, provided that the terms permit ++ modification of the work for the customer's own use and reverse ++ engineering for debugging such modifications. ++ ++ You must give prominent notice with each copy of the work that the ++ Library is used in it and that the Library and its use are covered by ++ this License. You must supply a copy of this License. If the work ++ during execution displays copyright notices, you must include the ++ copyright notice for the Library among them, as well as a reference ++ directing the user to the copy of this License. Also, you must do one ++ of these things: ++ ++ a) Accompany the work with the complete corresponding ++ machine-readable source code for the Library including whatever ++ changes were used in the work (which must be distributed under ++ Sections 1 and 2 above); and, if the work is an executable linked ++ with the Library, with the complete machine-readable "work that ++ uses the Library", as object code and/or source code, so that the ++ user can modify the Library and then relink to produce a modified ++ executable containing the modified Library. (It is understood ++ that the user who changes the contents of definitions files in the ++ Library will not necessarily be able to recompile the application ++ to use the modified definitions.) ++ ++ b) Use a suitable shared library mechanism for linking with the ++ Library. A suitable mechanism is one that (1) uses at run time a ++ copy of the library already present on the user's computer system, ++ rather than copying library functions into the executable, and (2) ++ will operate properly with a modified version of the library, if ++ the user installs one, as long as the modified version is ++ interface-compatible with the version that the work was made with. ++ ++ c) Accompany the work with a written offer, valid for at ++ least three years, to give the same user the materials ++ specified in Subsection 6a, above, for a charge no more ++ than the cost of performing this distribution. ++ ++ d) If distribution of the work is made by offering access to copy ++ from a designated place, offer equivalent access to copy the above ++ specified materials from the same place. ++ ++ e) Verify that the user has already received a copy of these ++ materials or that you have already sent this user a copy. ++ ++ For an executable, the required form of the "work that uses the ++ Library" must include any data and utility programs needed for ++ reproducing the executable from it. However, as a special exception, ++ the materials to be distributed need not include anything that is ++ normally distributed (in either source or binary form) with the major ++ components (compiler, kernel, and so on) of the operating system on ++ which the executable runs, unless that component itself accompanies ++ the executable. ++ ++ It may happen that this requirement contradicts the license ++ restrictions of other proprietary libraries that do not normally ++ accompany the operating system. Such a contradiction means you cannot ++ use both them and the Library together in an executable that you ++ distribute. ++ ++ 7. You may place library facilities that are a work based on the ++ Library side-by-side in a single library together with other library ++ facilities not covered by this License, and distribute such a combined ++ library, provided that the separate distribution of the work based on ++ the Library and of the other library facilities is otherwise ++ permitted, and provided that you do these two things: ++ ++ a) Accompany the combined library with a copy of the same work ++ based on the Library, uncombined with any other library ++ facilities. This must be distributed under the terms of the ++ Sections above. ++ ++ b) Give prominent notice with the combined library of the fact ++ that part of it is a work based on the Library, and explaining ++ where to find the accompanying uncombined form of the same work. ++ ++ 8. You may not copy, modify, sublicense, link with, or distribute ++ the Library except as expressly provided under this License. Any ++ attempt otherwise to copy, modify, sublicense, link with, or ++ distribute the Library is void, and will automatically terminate your ++ rights under this License. However, parties who have received copies, ++ or rights, from you under this License will not have their licenses ++ terminated so long as such parties remain in full compliance. ++ ++ 9. You are not required to accept this License, since you have not ++ signed it. However, nothing else grants you permission to modify or ++ distribute the Library or its derivative works. These actions are ++ prohibited by law if you do not accept this License. Therefore, by ++ modifying or distributing the Library (or any work based on the ++ Library), you indicate your acceptance of this License to do so, and ++ all its terms and conditions for copying, distributing or modifying ++ the Library or works based on it. ++ ++ 10. Each time you redistribute the Library (or any work based on the ++ Library), the recipient automatically receives a license from the ++ original licensor to copy, distribute, link with or modify the Library ++ subject to these terms and conditions. You may not impose any further ++ restrictions on the recipients' exercise of the rights granted herein. ++ You are not responsible for enforcing compliance by third parties with ++ this License. ++ ++ 11. If, as a consequence of a court judgment or allegation of patent ++ infringement or for any other reason (not limited to patent issues), ++ conditions are imposed on you (whether by court order, agreement or ++ otherwise) that contradict the conditions of this License, they do not ++ excuse you from the conditions of this License. If you cannot ++ distribute so as to satisfy simultaneously your obligations under this ++ License and any other pertinent obligations, then as a consequence you ++ may not distribute the Library at all. For example, if a patent ++ license would not permit royalty-free redistribution of the Library by ++ all those who receive copies directly or indirectly through you, then ++ the only way you could satisfy both it and this License would be to ++ refrain entirely from distribution of the Library. ++ ++ If any portion of this section is held invalid or unenforceable under any ++ particular circumstance, the balance of the section is intended to apply, ++ and the section as a whole is intended to apply in other circumstances. ++ ++ It is not the purpose of this section to induce you to infringe any ++ patents or other property right claims or to contest validity of any ++ such claims; this section has the sole purpose of protecting the ++ integrity of the free software distribution system which is ++ implemented by public license practices. Many people have made ++ generous contributions to the wide range of software distributed ++ through that system in reliance on consistent application of that ++ system; it is up to the author/donor to decide if he or she is willing ++ to distribute software through any other system and a licensee cannot ++ impose that choice. ++ ++ This section is intended to make thoroughly clear what is believed to ++ be a consequence of the rest of this License. ++ ++ 12. If the distribution and/or use of the Library is restricted in ++ certain countries either by patents or by copyrighted interfaces, the ++ original copyright holder who places the Library under this License may add ++ an explicit geographical distribution limitation excluding those countries, ++ so that distribution is permitted only in or among countries not thus ++ excluded. In such case, this License incorporates the limitation as if ++ written in the body of this License. ++ ++ 13. The Free Software Foundation may publish revised and/or new ++ versions of the Lesser General Public License from time to time. ++ Such new versions will be similar in spirit to the present version, ++ but may differ in detail to address new problems or concerns. ++ ++ Each version is given a distinguishing version number. If the Library ++ specifies a version number of this License which applies to it and ++ "any later version", you have the option of following the terms and ++ conditions either of that version or of any later version published by ++ the Free Software Foundation. If the Library does not specify a ++ license version number, you may choose any version ever published by ++ the Free Software Foundation. ++ ++ 14. If you wish to incorporate parts of the Library into other free ++ programs whose distribution conditions are incompatible with these, ++ write to the author to ask for permission. For software which is ++ copyrighted by the Free Software Foundation, write to the Free ++ Software Foundation; we sometimes make exceptions for this. Our ++ decision will be guided by the two goals of preserving the free status ++ of all derivatives of our free software and of promoting the sharing ++ and reuse of software generally. ++ ++ NO WARRANTY ++ ++ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO ++ WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. ++ EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR ++ OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY ++ KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE ++ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++ PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE ++ LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME ++ THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. ++ ++ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN ++ WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY ++ AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU ++ FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR ++ CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE ++ LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING ++ RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A ++ FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF ++ SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH ++ DAMAGES. ++ ++ END OF TERMS AND CONDITIONS ++ ++ How to Apply These Terms to Your New Libraries ++ ++ If you develop a new library, and you want it to be of the greatest ++ possible use to the public, we recommend making it free software that ++ everyone can redistribute and change. You can do so by permitting ++ redistribution under these terms (or, alternatively, under the terms of the ++ ordinary General Public License). ++ ++ To apply these terms, attach the following notices to the library. It is ++ safest to attach them to the start of each source file to most effectively ++ convey the exclusion of warranty; and each file should have at least the ++ "copyright" line and a pointer to where the full notice is found. ++ ++ <one line to give the library's name and a brief idea of what it does.> ++ Copyright (C) <year> <name of author> ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library; if not, write to the Free Software ++ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ ++ Also add information on how to contact you by electronic and paper mail. ++ ++ You should also get your employer (if you work as a programmer) or your ++ school, if any, to sign a "copyright disclaimer" for the library, if ++ necessary. Here is a sample; alter the names: ++ ++ Yoyodyne, Inc., hereby disclaims all copyright interest in the ++ library `Frob' (a library for tweaking knobs) written by James Random Hacker. ++ ++ <signature of Ty Coon>, 1 April 1990 ++ Ty Coon, President of Vice ++ ++ That's all there is to it! ++ ++ +*** ../vim-8.1.0359/src/xdiff/xdiff.h 1970-01-01 01:00:00.000000000 +0100 +--- src/xdiff/xdiff.h 2018-09-10 17:39:20.324083781 +0200 +*************** +*** 0 **** +--- 1,142 ---- ++ /* ++ * LibXDiff by Davide Libenzi ( File Differential Library ) ++ * Copyright (C) 2003 Davide Libenzi ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, see ++ * <http://www.gnu.org/licenses/>. ++ * ++ * Davide Libenzi <davidel@xmailserver.org> ++ * ++ */ ++ ++ #if !defined(XDIFF_H) ++ #define XDIFF_H ++ ++ #ifdef __cplusplus ++ extern "C" { ++ #endif /* #ifdef __cplusplus */ ++ ++ /* xpparm_t.flags */ ++ #define XDF_NEED_MINIMAL (1 << 0) ++ ++ #define XDF_IGNORE_WHITESPACE (1 << 1) ++ #define XDF_IGNORE_WHITESPACE_CHANGE (1 << 2) ++ #define XDF_IGNORE_WHITESPACE_AT_EOL (1 << 3) ++ #define XDF_IGNORE_CR_AT_EOL (1 << 4) ++ #define XDF_WHITESPACE_FLAGS (XDF_IGNORE_WHITESPACE | \ ++ XDF_IGNORE_WHITESPACE_CHANGE | \ ++ XDF_IGNORE_WHITESPACE_AT_EOL | \ ++ XDF_IGNORE_CR_AT_EOL) ++ ++ #define XDF_IGNORE_BLANK_LINES (1 << 7) ++ ++ #define XDF_PATIENCE_DIFF (1 << 14) ++ #define XDF_HISTOGRAM_DIFF (1 << 15) ++ #define XDF_DIFF_ALGORITHM_MASK (XDF_PATIENCE_DIFF | XDF_HISTOGRAM_DIFF) ++ #define XDF_DIFF_ALG(x) ((x) & XDF_DIFF_ALGORITHM_MASK) ++ ++ #define XDF_INDENT_HEURISTIC (1 << 23) ++ ++ /* xdemitconf_t.flags */ ++ #define XDL_EMIT_FUNCNAMES (1 << 0) ++ #define XDL_EMIT_FUNCCONTEXT (1 << 2) ++ ++ /* merge simplification levels */ ++ #define XDL_MERGE_MINIMAL 0 ++ #define XDL_MERGE_EAGER 1 ++ #define XDL_MERGE_ZEALOUS 2 ++ #define XDL_MERGE_ZEALOUS_ALNUM 3 ++ ++ /* merge favor modes */ ++ #define XDL_MERGE_FAVOR_OURS 1 ++ #define XDL_MERGE_FAVOR_THEIRS 2 ++ #define XDL_MERGE_FAVOR_UNION 3 ++ ++ /* merge output styles */ ++ #define XDL_MERGE_DIFF3 1 ++ ++ typedef struct s_mmfile { ++ char *ptr; ++ long size; ++ } mmfile_t; ++ ++ typedef struct s_mmbuffer { ++ char *ptr; ++ long size; ++ } mmbuffer_t; ++ ++ typedef struct s_xpparam { ++ unsigned long flags; ++ ++ /* See Documentation/diff-options.txt. */ ++ char **anchors; ++ size_t anchors_nr; ++ } xpparam_t; ++ ++ typedef struct s_xdemitcb { ++ void *priv; ++ int (*outf)(void *, mmbuffer_t *, int); ++ } xdemitcb_t; ++ ++ typedef long (*find_func_t)(const char *line, long line_len, char *buffer, long buffer_size, void *priv); ++ ++ typedef int (*xdl_emit_hunk_consume_func_t)(long start_a, long count_a, ++ long start_b, long count_b, ++ void *cb_data); ++ ++ typedef struct s_xdemitconf { ++ long ctxlen; ++ long interhunkctxlen; ++ unsigned long flags; ++ find_func_t find_func; ++ void *find_func_priv; ++ xdl_emit_hunk_consume_func_t hunk_func; ++ } xdemitconf_t; ++ ++ typedef struct s_bdiffparam { ++ long bsize; ++ } bdiffparam_t; ++ ++ ++ #define xdl_malloc(x) malloc(x) ++ #define xdl_free(ptr) free(ptr) ++ #define xdl_realloc(ptr,x) realloc(ptr,x) ++ ++ void *xdl_mmfile_first(mmfile_t *mmf, long *size); ++ long xdl_mmfile_size(mmfile_t *mmf); ++ ++ int xdl_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, ++ xdemitconf_t const *xecfg, xdemitcb_t *ecb); ++ ++ typedef struct s_xmparam { ++ xpparam_t xpp; ++ int marker_size; ++ int level; ++ int favor; ++ int style; ++ const char *ancestor; /* label for orig */ ++ const char *file1; /* label for mf1 */ ++ const char *file2; /* label for mf2 */ ++ } xmparam_t; ++ ++ #define DEFAULT_CONFLICT_MARKER_SIZE 7 ++ ++ int xdl_merge(mmfile_t *orig, mmfile_t *mf1, mmfile_t *mf2, ++ xmparam_t const *xmp, mmbuffer_t *result); ++ ++ #ifdef __cplusplus ++ } ++ #endif /* #ifdef __cplusplus */ ++ ++ #endif /* #if !defined(XDIFF_H) */ +*** ../vim-8.1.0359/src/xdiff/xdiffi.c 1970-01-01 01:00:00.000000000 +0100 +--- src/xdiff/xdiffi.c 2018-09-10 17:39:20.324083781 +0200 +*************** +*** 0 **** +--- 1,1043 ---- ++ /* ++ * LibXDiff by Davide Libenzi ( File Differential Library ) ++ * Copyright (C) 2003 Davide Libenzi ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, see ++ * <http://www.gnu.org/licenses/>. ++ * ++ * Davide Libenzi <davidel@xmailserver.org> ++ * ++ */ ++ ++ #include "xinclude.h" ++ ++ #define XDL_MAX_COST_MIN 256 ++ #define XDL_HEUR_MIN_COST 256 ++ #define XDL_LINE_MAX (long)((1UL << (CHAR_BIT * sizeof(long) - 1)) - 1) ++ #define XDL_SNAKE_CNT 20 ++ #define XDL_K_HEUR 4 ++ ++ typedef struct s_xdpsplit { ++ long i1, i2; ++ int min_lo, min_hi; ++ } xdpsplit_t; ++ ++ /* ++ * See "An O(ND) Difference Algorithm and its Variations", by Eugene Myers. ++ * Basically considers a "box" (off1, off2, lim1, lim2) and scan from both ++ * the forward diagonal starting from (off1, off2) and the backward diagonal ++ * starting from (lim1, lim2). If the K values on the same diagonal crosses ++ * returns the furthest point of reach. We might end up having to expensive ++ * cases using this algorithm is full, so a little bit of heuristic is needed ++ * to cut the search and to return a suboptimal point. ++ */ ++ static long xdl_split(unsigned long const *ha1, long off1, long lim1, ++ unsigned long const *ha2, long off2, long lim2, ++ long *kvdf, long *kvdb, int need_min, xdpsplit_t *spl, ++ xdalgoenv_t *xenv) { ++ long dmin = off1 - lim2, dmax = lim1 - off2; ++ long fmid = off1 - off2, bmid = lim1 - lim2; ++ long odd = (fmid - bmid) & 1; ++ long fmin = fmid, fmax = fmid; ++ long bmin = bmid, bmax = bmid; ++ long ec, d, i1, i2, prev1, best, dd, v, k; ++ ++ /* ++ * Set initial diagonal values for both forward and backward path. ++ */ ++ kvdf[fmid] = off1; ++ kvdb[bmid] = lim1; ++ ++ for (ec = 1;; ec++) { ++ int got_snake = 0; ++ ++ /* ++ * We need to extent the diagonal "domain" by one. If the next ++ * values exits the box boundaries we need to change it in the ++ * opposite direction because (max - min) must be a power of two. ++ * Also we initialize the external K value to -1 so that we can ++ * avoid extra conditions check inside the core loop. ++ */ ++ if (fmin > dmin) ++ kvdf[--fmin - 1] = -1; ++ else ++ ++fmin; ++ if (fmax < dmax) ++ kvdf[++fmax + 1] = -1; ++ else ++ --fmax; ++ ++ for (d = fmax; d >= fmin; d -= 2) { ++ if (kvdf[d - 1] >= kvdf[d + 1]) ++ i1 = kvdf[d - 1] + 1; ++ else ++ i1 = kvdf[d + 1]; ++ prev1 = i1; ++ i2 = i1 - d; ++ for (; i1 < lim1 && i2 < lim2 && ha1[i1] == ha2[i2]; i1++, i2++); ++ if (i1 - prev1 > xenv->snake_cnt) ++ got_snake = 1; ++ kvdf[d] = i1; ++ if (odd && bmin <= d && d <= bmax && kvdb[d] <= i1) { ++ spl->i1 = i1; ++ spl->i2 = i2; ++ spl->min_lo = spl->min_hi = 1; ++ return ec; ++ } ++ } ++ ++ /* ++ * We need to extent the diagonal "domain" by one. If the next ++ * values exits the box boundaries we need to change it in the ++ * opposite direction because (max - min) must be a power of two. ++ * Also we initialize the external K value to -1 so that we can ++ * avoid extra conditions check inside the core loop. ++ */ ++ if (bmin > dmin) ++ kvdb[--bmin - 1] = XDL_LINE_MAX; ++ else ++ ++bmin; ++ if (bmax < dmax) ++ kvdb[++bmax + 1] = XDL_LINE_MAX; ++ else ++ --bmax; ++ ++ for (d = bmax; d >= bmin; d -= 2) { ++ if (kvdb[d - 1] < kvdb[d + 1]) ++ i1 = kvdb[d - 1]; ++ else ++ i1 = kvdb[d + 1] - 1; ++ prev1 = i1; ++ i2 = i1 - d; ++ for (; i1 > off1 && i2 > off2 && ha1[i1 - 1] == ha2[i2 - 1]; i1--, i2--); ++ if (prev1 - i1 > xenv->snake_cnt) ++ got_snake = 1; ++ kvdb[d] = i1; ++ if (!odd && fmin <= d && d <= fmax && i1 <= kvdf[d]) { ++ spl->i1 = i1; ++ spl->i2 = i2; ++ spl->min_lo = spl->min_hi = 1; ++ return ec; ++ } ++ } ++ ++ if (need_min) ++ continue; ++ ++ /* ++ * If the edit cost is above the heuristic trigger and if ++ * we got a good snake, we sample current diagonals to see ++ * if some of the, have reached an "interesting" path. Our ++ * measure is a function of the distance from the diagonal ++ * corner (i1 + i2) penalized with the distance from the ++ * mid diagonal itself. If this value is above the current ++ * edit cost times a magic factor (XDL_K_HEUR) we consider ++ * it interesting. ++ */ ++ if (got_snake && ec > xenv->heur_min) { ++ for (best = 0, d = fmax; d >= fmin; d -= 2) { ++ dd = d > fmid ? d - fmid: fmid - d; ++ i1 = kvdf[d]; ++ i2 = i1 - d; ++ v = (i1 - off1) + (i2 - off2) - dd; ++ ++ if (v > XDL_K_HEUR * ec && v > best && ++ off1 + xenv->snake_cnt <= i1 && i1 < lim1 && ++ off2 + xenv->snake_cnt <= i2 && i2 < lim2) { ++ for (k = 1; ha1[i1 - k] == ha2[i2 - k]; k++) ++ if (k == xenv->snake_cnt) { ++ best = v; ++ spl->i1 = i1; ++ spl->i2 = i2; ++ break; ++ } ++ } ++ } ++ if (best > 0) { ++ spl->min_lo = 1; ++ spl->min_hi = 0; ++ return ec; ++ } ++ ++ for (best = 0, d = bmax; d >= bmin; d -= 2) { ++ dd = d > bmid ? d - bmid: bmid - d; ++ i1 = kvdb[d]; ++ i2 = i1 - d; ++ v = (lim1 - i1) + (lim2 - i2) - dd; ++ ++ if (v > XDL_K_HEUR * ec && v > best && ++ off1 < i1 && i1 <= lim1 - xenv->snake_cnt && ++ off2 < i2 && i2 <= lim2 - xenv->snake_cnt) { ++ for (k = 0; ha1[i1 + k] == ha2[i2 + k]; k++) ++ if (k == xenv->snake_cnt - 1) { ++ best = v; ++ spl->i1 = i1; ++ spl->i2 = i2; ++ break; ++ } ++ } ++ } ++ if (best > 0) { ++ spl->min_lo = 0; ++ spl->min_hi = 1; ++ return ec; ++ } ++ } ++ ++ /* ++ * Enough is enough. We spent too much time here and now we collect ++ * the furthest reaching path using the (i1 + i2) measure. ++ */ ++ if (ec >= xenv->mxcost) { ++ long fbest, fbest1, bbest, bbest1; ++ ++ fbest = fbest1 = -1; ++ for (d = fmax; d >= fmin; d -= 2) { ++ i1 = XDL_MIN(kvdf[d], lim1); ++ i2 = i1 - d; ++ if (lim2 < i2) ++ i1 = lim2 + d, i2 = lim2; ++ if (fbest < i1 + i2) { ++ fbest = i1 + i2; ++ fbest1 = i1; ++ } ++ } ++ ++ bbest = bbest1 = XDL_LINE_MAX; ++ for (d = bmax; d >= bmin; d -= 2) { ++ i1 = XDL_MAX(off1, kvdb[d]); ++ i2 = i1 - d; ++ if (i2 < off2) ++ i1 = off2 + d, i2 = off2; ++ if (i1 + i2 < bbest) { ++ bbest = i1 + i2; ++ bbest1 = i1; ++ } ++ } ++ ++ if ((lim1 + lim2) - bbest < fbest - (off1 + off2)) { ++ spl->i1 = fbest1; ++ spl->i2 = fbest - fbest1; ++ spl->min_lo = 1; ++ spl->min_hi = 0; ++ } else { ++ spl->i1 = bbest1; ++ spl->i2 = bbest - bbest1; ++ spl->min_lo = 0; ++ spl->min_hi = 1; ++ } ++ return ec; ++ } ++ } ++ } ++ ++ ++ /* ++ * Rule: "Divide et Impera". Recursively split the box in sub-boxes by calling ++ * the box splitting function. Note that the real job (marking changed lines) ++ * is done in the two boundary reaching checks. ++ */ ++ int xdl_recs_cmp(diffdata_t *dd1, long off1, long lim1, ++ diffdata_t *dd2, long off2, long lim2, ++ long *kvdf, long *kvdb, int need_min, xdalgoenv_t *xenv) { ++ unsigned long const *ha1 = dd1->ha, *ha2 = dd2->ha; ++ ++ /* ++ * Shrink the box by walking through each diagonal snake (SW and NE). ++ */ ++ for (; off1 < lim1 && off2 < lim2 && ha1[off1] == ha2[off2]; off1++, off2++); ++ for (; off1 < lim1 && off2 < lim2 && ha1[lim1 - 1] == ha2[lim2 - 1]; lim1--, lim2--); ++ ++ /* ++ * If one dimension is empty, then all records on the other one must ++ * be obviously changed. ++ */ ++ if (off1 == lim1) { ++ char *rchg2 = dd2->rchg; ++ long *rindex2 = dd2->rindex; ++ ++ for (; off2 < lim2; off2++) ++ rchg2[rindex2[off2]] = 1; ++ } else if (off2 == lim2) { ++ char *rchg1 = dd1->rchg; ++ long *rindex1 = dd1->rindex; ++ ++ for (; off1 < lim1; off1++) ++ rchg1[rindex1[off1]] = 1; ++ } else { ++ xdpsplit_t spl; ++ spl.i1 = spl.i2 = 0; ++ ++ /* ++ * Divide ... ++ */ ++ if (xdl_split(ha1, off1, lim1, ha2, off2, lim2, kvdf, kvdb, ++ need_min, &spl, xenv) < 0) { ++ ++ return -1; ++ } ++ ++ /* ++ * ... et Impera. ++ */ ++ if (xdl_recs_cmp(dd1, off1, spl.i1, dd2, off2, spl.i2, ++ kvdf, kvdb, spl.min_lo, xenv) < 0 || ++ xdl_recs_cmp(dd1, spl.i1, lim1, dd2, spl.i2, lim2, ++ kvdf, kvdb, spl.min_hi, xenv) < 0) { ++ ++ return -1; ++ } ++ } ++ ++ return 0; ++ } ++ ++ ++ int xdl_do_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, ++ xdfenv_t *xe) { ++ long ndiags; ++ long *kvd, *kvdf, *kvdb; ++ xdalgoenv_t xenv; ++ diffdata_t dd1, dd2; ++ ++ if (XDF_DIFF_ALG(xpp->flags) == XDF_PATIENCE_DIFF) ++ return xdl_do_patience_diff(mf1, mf2, xpp, xe); ++ ++ if (XDF_DIFF_ALG(xpp->flags) == XDF_HISTOGRAM_DIFF) ++ return xdl_do_histogram_diff(mf1, mf2, xpp, xe); ++ ++ if (xdl_prepare_env(mf1, mf2, xpp, xe) < 0) { ++ ++ return -1; ++ } ++ ++ /* ++ * Allocate and setup K vectors to be used by the differential algorithm. ++ * One is to store the forward path and one to store the backward path. ++ */ ++ ndiags = xe->xdf1.nreff + xe->xdf2.nreff + 3; ++ if (!(kvd = (long *) xdl_malloc((2 * ndiags + 2) * sizeof(long)))) { ++ ++ xdl_free_env(xe); ++ return -1; ++ } ++ kvdf = kvd; ++ kvdb = kvdf + ndiags; ++ kvdf += xe->xdf2.nreff + 1; ++ kvdb += xe->xdf2.nreff + 1; ++ ++ xenv.mxcost = xdl_bogosqrt(ndiags); ++ if (xenv.mxcost < XDL_MAX_COST_MIN) ++ xenv.mxcost = XDL_MAX_COST_MIN; ++ xenv.snake_cnt = XDL_SNAKE_CNT; ++ xenv.heur_min = XDL_HEUR_MIN_COST; ++ ++ dd1.nrec = xe->xdf1.nreff; ++ dd1.ha = xe->xdf1.ha; ++ dd1.rchg = xe->xdf1.rchg; ++ dd1.rindex = xe->xdf1.rindex; ++ dd2.nrec = xe->xdf2.nreff; ++ dd2.ha = xe->xdf2.ha; ++ dd2.rchg = xe->xdf2.rchg; ++ dd2.rindex = xe->xdf2.rindex; ++ ++ if (xdl_recs_cmp(&dd1, 0, dd1.nrec, &dd2, 0, dd2.nrec, ++ kvdf, kvdb, (xpp->flags & XDF_NEED_MINIMAL) != 0, &xenv) < 0) { ++ ++ xdl_free(kvd); ++ xdl_free_env(xe); ++ return -1; ++ } ++ ++ xdl_free(kvd); ++ ++ return 0; ++ } ++ ++ ++ static xdchange_t *xdl_add_change(xdchange_t *xscr, long i1, long i2, long chg1, long chg2) { ++ xdchange_t *xch; ++ ++ if (!(xch = (xdchange_t *) xdl_malloc(sizeof(xdchange_t)))) ++ return NULL; ++ ++ xch->next = xscr; ++ xch->i1 = i1; ++ xch->i2 = i2; ++ xch->chg1 = chg1; ++ xch->chg2 = chg2; ++ xch->ignore = 0; ++ ++ return xch; ++ } ++ ++ ++ static int recs_match(xrecord_t *rec1, xrecord_t *rec2, long flags) ++ { ++ return (rec1->ha == rec2->ha && ++ xdl_recmatch(rec1->ptr, rec1->size, ++ rec2->ptr, rec2->size, ++ flags)); ++ } ++ ++ /* ++ * If a line is indented more than this, get_indent() just returns this value. ++ * This avoids having to do absurd amounts of work for data that are not ++ * human-readable text, and also ensures that the output of get_indent fits within ++ * an int. ++ */ ++ #define MAX_INDENT 200 ++ ++ /* ++ * Return the amount of indentation of the specified line, treating TAB as 8 ++ * columns. Return -1 if line is empty or contains only whitespace. Clamp the ++ * output value at MAX_INDENT. ++ */ ++ static int get_indent(xrecord_t *rec) ++ { ++ long i; ++ int ret = 0; ++ ++ for (i = 0; i < rec->size; i++) { ++ char c = rec->ptr[i]; ++ ++ if (!XDL_ISSPACE(c)) ++ return ret; ++ else if (c == ' ') ++ ret += 1; ++ else if (c == '\t') ++ ret += 8 - ret % 8; ++ /* ignore other whitespace characters */ ++ ++ if (ret >= MAX_INDENT) ++ return MAX_INDENT; ++ } ++ ++ /* The line contains only whitespace. */ ++ return -1; ++ } ++ ++ /* ++ * If more than this number of consecutive blank rows are found, just return this ++ * value. This avoids requiring O(N^2) work for pathological cases, and also ++ * ensures that the output of score_split fits in an int. ++ */ ++ #define MAX_BLANKS 20 ++ ++ /* Characteristics measured about a hypothetical split position. */ ++ struct split_measurement { ++ /* ++ * Is the split at the end of the file (aside from any blank lines)? ++ */ ++ int end_of_file; ++ ++ /* ++ * How much is the line immediately following the split indented (or -1 if ++ * the line is blank): ++ */ ++ int indent; ++ ++ /* ++ * How many consecutive lines above the split are blank? ++ */ ++ int pre_blank; ++ ++ /* ++ * How much is the nearest non-blank line above the split indented (or -1 ++ * if there is no such line)? ++ */ ++ int pre_indent; ++ ++ /* ++ * How many lines after the line following the split are blank? ++ */ ++ int post_blank; ++ ++ /* ++ * How much is the nearest non-blank line after the line following the ++ * split indented (or -1 if there is no such line)? ++ */ ++ int post_indent; ++ }; ++ ++ struct split_score { ++ /* The effective indent of this split (smaller is preferred). */ ++ int effective_indent; ++ ++ /* Penalty for this split (smaller is preferred). */ ++ int penalty; ++ }; ++ ++ /* ++ * Fill m with information about a hypothetical split of xdf above line split. ++ */ ++ static void measure_split(const xdfile_t *xdf, long split, ++ struct split_measurement *m) ++ { ++ long i; ++ ++ if (split >= xdf->nrec) { ++ m->end_of_file = 1; ++ m->indent = -1; ++ } else { ++ m->end_of_file = 0; ++ m->indent = get_indent(xdf->recs[split]); ++ } ++ ++ m->pre_blank = 0; ++ m->pre_indent = -1; ++ for (i = split - 1; i >= 0; i--) { ++ m->pre_indent = get_indent(xdf->recs[i]); ++ if (m->pre_indent != -1) ++ break; ++ m->pre_blank += 1; ++ if (m->pre_blank == MAX_BLANKS) { ++ m->pre_indent = 0; ++ break; ++ } ++ } ++ ++ m->post_blank = 0; ++ m->post_indent = -1; ++ for (i = split + 1; i < xdf->nrec; i++) { ++ m->post_indent = get_indent(xdf->recs[i]); ++ if (m->post_indent != -1) ++ break; ++ m->post_blank += 1; ++ if (m->post_blank == MAX_BLANKS) { ++ m->post_indent = 0; ++ break; ++ } ++ } ++ } ++ ++ /* ++ * The empirically-determined weight factors used by score_split() below. ++ * Larger values means that the position is a less favorable place to split. ++ * ++ * Note that scores are only ever compared against each other, so multiplying ++ * all of these weight/penalty values by the same factor wouldn't change the ++ * heuristic's behavior. Still, we need to set that arbitrary scale *somehow*. ++ * In practice, these numbers are chosen to be large enough that they can be ++ * adjusted relative to each other with sufficient precision despite using ++ * integer math. ++ */ ++ ++ /* Penalty if there are no non-blank lines before the split */ ++ #define START_OF_FILE_PENALTY 1 ++ ++ /* Penalty if there are no non-blank lines after the split */ ++ #define END_OF_FILE_PENALTY 21 ++ ++ /* Multiplier for the number of blank lines around the split */ ++ #define TOTAL_BLANK_WEIGHT (-30) ++ ++ /* Multiplier for the number of blank lines after the split */ ++ #define POST_BLANK_WEIGHT 6 ++ ++ /* ++ * Penalties applied if the line is indented more than its predecessor ++ */ ++ #define RELATIVE_INDENT_PENALTY (-4) ++ #define RELATIVE_INDENT_WITH_BLANK_PENALTY 10 ++ ++ /* ++ * Penalties applied if the line is indented less than both its predecessor and ++ * its successor ++ */ ++ #define RELATIVE_OUTDENT_PENALTY 24 ++ #define RELATIVE_OUTDENT_WITH_BLANK_PENALTY 17 ++ ++ /* ++ * Penalties applied if the line is indented less than its predecessor but not ++ * less than its successor ++ */ ++ #define RELATIVE_DEDENT_PENALTY 23 ++ #define RELATIVE_DEDENT_WITH_BLANK_PENALTY 17 ++ ++ /* ++ * We only consider whether the sum of the effective indents for splits are ++ * less than (-1), equal to (0), or greater than (+1) each other. The resulting ++ * value is multiplied by the following weight and combined with the penalty to ++ * determine the better of two scores. ++ */ ++ #define INDENT_WEIGHT 60 ++ ++ /* ++ * How far do we slide a hunk at most? ++ */ ++ #define INDENT_HEURISTIC_MAX_SLIDING 100 ++ ++ /* ++ * Compute a badness score for the hypothetical split whose measurements are ++ * stored in m. The weight factors were determined empirically using the tools and ++ * corpus described in ++ * ++ * https://github.com/mhagger/diff-slider-tools ++ * ++ * Also see that project if you want to improve the weights based on, for example, ++ * a larger or more diverse corpus. ++ */ ++ static void score_add_split(const struct split_measurement *m, struct split_score *s) ++ { ++ /* ++ * A place to accumulate penalty factors (positive makes this index more ++ * favored): ++ */ ++ int post_blank, total_blank, indent, any_blanks; ++ ++ if (m->pre_indent == -1 && m->pre_blank == 0) ++ s->penalty += START_OF_FILE_PENALTY; ++ ++ if (m->end_of_file) ++ s->penalty += END_OF_FILE_PENALTY; ++ ++ /* ++ * Set post_blank to the number of blank lines following the split, ++ * including the line immediately after the split: ++ */ ++ post_blank = (m->indent == -1) ? 1 + m->post_blank : 0; ++ total_blank = m->pre_blank + post_blank; ++ ++ /* Penalties based on nearby blank lines: */ ++ s->penalty += TOTAL_BLANK_WEIGHT * total_blank; ++ s->penalty += POST_BLANK_WEIGHT * post_blank; ++ ++ if (m->indent != -1) ++ indent = m->indent; ++ else ++ indent = m->post_indent; ++ ++ any_blanks = (total_blank != 0); ++ ++ /* Note that the effective indent is -1 at the end of the file: */ ++ s->effective_indent += indent; ++ ++ if (indent == -1) { ++ /* No additional adjustments needed. */ ++ } else if (m->pre_indent == -1) { ++ /* No additional adjustments needed. */ ++ } else if (indent > m->pre_indent) { ++ /* ++ * The line is indented more than its predecessor. ++ */ ++ s->penalty += any_blanks ? ++ RELATIVE_INDENT_WITH_BLANK_PENALTY : ++ RELATIVE_INDENT_PENALTY; ++ } else if (indent == m->pre_indent) { ++ /* ++ * The line has the same indentation level as its predecessor. ++ * No additional adjustments needed. ++ */ ++ } else { ++ /* ++ * The line is indented less than its predecessor. It could be ++ * the block terminator of the previous block, but it could ++ * also be the start of a new block (e.g., an "else" block, or ++ * maybe the previous block didn't have a block terminator). ++ * Try to distinguish those cases based on what comes next: ++ */ ++ if (m->post_indent != -1 && m->post_indent > indent) { ++ /* ++ * The following line is indented more. So it is likely ++ * that this line is the start of a block. ++ */ ++ s->penalty += any_blanks ? ++ RELATIVE_OUTDENT_WITH_BLANK_PENALTY : ++ RELATIVE_OUTDENT_PENALTY; ++ } else { ++ /* ++ * That was probably the end of a block. ++ */ ++ s->penalty += any_blanks ? ++ RELATIVE_DEDENT_WITH_BLANK_PENALTY : ++ RELATIVE_DEDENT_PENALTY; ++ } ++ } ++ } ++ ++ static int score_cmp(struct split_score *s1, struct split_score *s2) ++ { ++ /* -1 if s1.effective_indent < s2->effective_indent, etc. */ ++ int cmp_indents = ((s1->effective_indent > s2->effective_indent) - ++ (s1->effective_indent < s2->effective_indent)); ++ ++ return INDENT_WEIGHT * cmp_indents + (s1->penalty - s2->penalty); ++ } ++ ++ /* ++ * Represent a group of changed lines in an xdfile_t (i.e., a contiguous group ++ * of lines that was inserted or deleted from the corresponding version of the ++ * file). We consider there to be such a group at the beginning of the file, at ++ * the end of the file, and between any two unchanged lines, though most such ++ * groups will usually be empty. ++ * ++ * If the first line in a group is equal to the line following the group, then ++ * the group can be slid down. Similarly, if the last line in a group is equal ++ * to the line preceding the group, then the group can be slid up. See ++ * group_slide_down() and group_slide_up(). ++ * ++ * Note that loops that are testing for changed lines in xdf->rchg do not need ++ * index bounding since the array is prepared with a zero at position -1 and N. ++ */ ++ struct xdlgroup { ++ /* ++ * The index of the first changed line in the group, or the index of ++ * the unchanged line above which the (empty) group is located. ++ */ ++ long start; ++ ++ /* ++ * The index of the first unchanged line after the group. For an empty ++ * group, end is equal to start. ++ */ ++ long end; ++ }; ++ ++ /* ++ * Initialize g to point at the first group in xdf. ++ */ ++ static void group_init(xdfile_t *xdf, struct xdlgroup *g) ++ { ++ g->start = g->end = 0; ++ while (xdf->rchg[g->end]) ++ g->end++; ++ } ++ ++ /* ++ * Move g to describe the next (possibly empty) group in xdf and return 0. If g ++ * is already at the end of the file, do nothing and return -1. ++ */ ++ static inline int group_next(xdfile_t *xdf, struct xdlgroup *g) ++ { ++ if (g->end == xdf->nrec) ++ return -1; ++ ++ g->start = g->end + 1; ++ for (g->end = g->start; xdf->rchg[g->end]; g->end++) ++ ; ++ ++ return 0; ++ } ++ ++ /* ++ * Move g to describe the previous (possibly empty) group in xdf and return 0. ++ * If g is already at the beginning of the file, do nothing and return -1. ++ */ ++ static inline int group_previous(xdfile_t *xdf, struct xdlgroup *g) ++ { ++ if (g->start == 0) ++ return -1; ++ ++ g->end = g->start - 1; ++ for (g->start = g->end; xdf->rchg[g->start - 1]; g->start--) ++ ; ++ ++ return 0; ++ } ++ ++ /* ++ * If g can be slid toward the end of the file, do so, and if it bumps into a ++ * following group, expand this group to include it. Return 0 on success or -1 ++ * if g cannot be slid down. ++ */ ++ static int group_slide_down(xdfile_t *xdf, struct xdlgroup *g, long flags) ++ { ++ if (g->end < xdf->nrec && ++ recs_match(xdf->recs[g->start], xdf->recs[g->end], flags)) { ++ xdf->rchg[g->start++] = 0; ++ xdf->rchg[g->end++] = 1; ++ ++ while (xdf->rchg[g->end]) ++ g->end++; ++ ++ return 0; ++ } else { ++ return -1; ++ } ++ } ++ ++ /* ++ * If g can be slid toward the beginning of the file, do so, and if it bumps ++ * into a previous group, expand this group to include it. Return 0 on success ++ * or -1 if g cannot be slid up. ++ */ ++ static int group_slide_up(xdfile_t *xdf, struct xdlgroup *g, long flags) ++ { ++ if (g->start > 0 && ++ recs_match(xdf->recs[g->start - 1], xdf->recs[g->end - 1], flags)) { ++ xdf->rchg[--g->start] = 1; ++ xdf->rchg[--g->end] = 0; ++ ++ while (xdf->rchg[g->start - 1]) ++ g->start--; ++ ++ return 0; ++ } else { ++ return -1; ++ } ++ } ++ ++ static void xdl_bug(const char *msg) ++ { ++ fprintf(stderr, "BUG: %s\n", msg); ++ exit(1); ++ } ++ ++ /* ++ * Move back and forward change groups for a consistent and pretty diff output. ++ * This also helps in finding joinable change groups and reducing the diff ++ * size. ++ */ ++ int xdl_change_compact(xdfile_t *xdf, xdfile_t *xdfo, long flags) { ++ struct xdlgroup g, go; ++ long earliest_end, end_matching_other; ++ long groupsize; ++ ++ group_init(xdf, &g); ++ group_init(xdfo, &go); ++ ++ while (1) { ++ /* If the group is empty in the to-be-compacted file, skip it: */ ++ if (g.end == g.start) ++ goto next; ++ ++ /* ++ * Now shift the change up and then down as far as possible in ++ * each direction. If it bumps into any other changes, merge them. ++ */ ++ do { ++ groupsize = g.end - g.start; ++ ++ /* ++ * Keep track of the last "end" index that causes this ++ * group to align with a group of changed lines in the ++ * other file. -1 indicates that we haven't found such ++ * a match yet: ++ */ ++ end_matching_other = -1; ++ ++ /* Shift the group backward as much as possible: */ ++ while (!group_slide_up(xdf, &g, flags)) ++ if (group_previous(xdfo, &go)) ++ xdl_bug("group sync broken sliding up"); ++ ++ /* ++ * This is this highest that this group can be shifted. ++ * Record its end index: ++ */ ++ earliest_end = g.end; ++ ++ if (go.end > go.start) ++ end_matching_other = g.end; ++ ++ /* Now shift the group forward as far as possible: */ ++ while (1) { ++ if (group_slide_down(xdf, &g, flags)) ++ break; ++ if (group_next(xdfo, &go)) ++ xdl_bug("group sync broken sliding down"); ++ ++ if (go.end > go.start) ++ end_matching_other = g.end; ++ } ++ } while (groupsize != g.end - g.start); ++ ++ /* ++ * If the group can be shifted, then we can possibly use this ++ * freedom to produce a more intuitive diff. ++ * ++ * The group is currently shifted as far down as possible, so the ++ * heuristics below only have to handle upwards shifts. ++ */ ++ ++ if (g.end == earliest_end) { ++ /* no shifting was possible */ ++ } else if (end_matching_other != -1) { ++ /* ++ * Move the possibly merged group of changes back to line ++ * up with the last group of changes from the other file ++ * that it can align with. ++ */ ++ while (go.end == go.start) { ++ if (group_slide_up(xdf, &g, flags)) ++ xdl_bug("match disappeared"); ++ if (group_previous(xdfo, &go)) ++ xdl_bug("group sync broken sliding to match"); ++ } ++ } else if (flags & XDF_INDENT_HEURISTIC) { ++ /* ++ * Indent heuristic: a group of pure add/delete lines ++ * implies two splits, one between the end of the "before" ++ * context and the start of the group, and another between ++ * the end of the group and the beginning of the "after" ++ * context. Some splits are aesthetically better and some ++ * are worse. We compute a badness "score" for each split, ++ * and add the scores for the two splits to define a ++ * "score" for each position that the group can be shifted ++ * to. Then we pick the shift with the lowest score. ++ */ ++ long shift, best_shift = -1; ++ struct split_score best_score; ++ ++ shift = earliest_end; ++ if (g.end - groupsize - 1 > shift) ++ shift = g.end - groupsize - 1; ++ if (g.end - INDENT_HEURISTIC_MAX_SLIDING > shift) ++ shift = g.end - INDENT_HEURISTIC_MAX_SLIDING; ++ for (; shift <= g.end; shift++) { ++ struct split_measurement m; ++ struct split_score score = {0, 0}; ++ ++ measure_split(xdf, shift, &m); ++ score_add_split(&m, &score); ++ measure_split(xdf, shift - groupsize, &m); ++ score_add_split(&m, &score); ++ if (best_shift == -1 || ++ score_cmp(&score, &best_score) <= 0) { ++ best_score.effective_indent = score.effective_indent; ++ best_score.penalty = score.penalty; ++ best_shift = shift; ++ } ++ } ++ ++ while (g.end > best_shift) { ++ if (group_slide_up(xdf, &g, flags)) ++ xdl_bug("best shift unreached"); ++ if (group_previous(xdfo, &go)) ++ xdl_bug("group sync broken sliding to blank line"); ++ } ++ } ++ ++ next: ++ /* Move past the just-processed group: */ ++ if (group_next(xdf, &g)) ++ break; ++ if (group_next(xdfo, &go)) ++ xdl_bug("group sync broken moving to next group"); ++ } ++ ++ if (!group_next(xdfo, &go)) ++ xdl_bug("group sync broken at end of file"); ++ ++ return 0; ++ } ++ ++ ++ int xdl_build_script(xdfenv_t *xe, xdchange_t **xscr) { ++ xdchange_t *cscr = NULL, *xch; ++ char *rchg1 = xe->xdf1.rchg, *rchg2 = xe->xdf2.rchg; ++ long i1, i2, l1, l2; ++ ++ /* ++ * Trivial. Collects "groups" of changes and creates an edit script. ++ */ ++ for (i1 = xe->xdf1.nrec, i2 = xe->xdf2.nrec; i1 >= 0 || i2 >= 0; i1--, i2--) ++ if (rchg1[i1 - 1] || rchg2[i2 - 1]) { ++ for (l1 = i1; rchg1[i1 - 1]; i1--); ++ for (l2 = i2; rchg2[i2 - 1]; i2--); ++ ++ if (!(xch = xdl_add_change(cscr, i1, i2, l1 - i1, l2 - i2))) { ++ xdl_free_script(cscr); ++ return -1; ++ } ++ cscr = xch; ++ } ++ ++ *xscr = cscr; ++ ++ return 0; ++ } ++ ++ ++ void xdl_free_script(xdchange_t *xscr) { ++ xdchange_t *xch; ++ ++ while ((xch = xscr) != NULL) { ++ xscr = xscr->next; ++ xdl_free(xch); ++ } ++ } ++ ++ static int xdl_call_hunk_func(xdfenv_t *xe UNUSED, xdchange_t *xscr, xdemitcb_t *ecb, ++ xdemitconf_t const *xecfg) ++ { ++ xdchange_t *xch, *xche; ++ ++ for (xch = xscr; xch; xch = xche->next) { ++ xche = xdl_get_hunk(&xch, xecfg); ++ if (!xch) ++ break; ++ if (xecfg->hunk_func(xch->i1, xche->i1 + xche->chg1 - xch->i1, ++ xch->i2, xche->i2 + xche->chg2 - xch->i2, ++ ecb->priv) < 0) ++ return -1; ++ } ++ return 0; ++ } ++ ++ static void xdl_mark_ignorable(xdchange_t *xscr, xdfenv_t *xe, long flags) ++ { ++ xdchange_t *xch; ++ ++ for (xch = xscr; xch; xch = xch->next) { ++ int ignore = 1; ++ xrecord_t **rec; ++ long i; ++ ++ rec = &xe->xdf1.recs[xch->i1]; ++ for (i = 0; i < xch->chg1 && ignore; i++) ++ ignore = xdl_blankline(rec[i]->ptr, rec[i]->size, flags); ++ ++ rec = &xe->xdf2.recs[xch->i2]; ++ for (i = 0; i < xch->chg2 && ignore; i++) ++ ignore = xdl_blankline(rec[i]->ptr, rec[i]->size, flags); ++ ++ xch->ignore = ignore; ++ } ++ } ++ ++ int xdl_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, ++ xdemitconf_t const *xecfg, xdemitcb_t *ecb) { ++ xdchange_t *xscr; ++ xdfenv_t xe; ++ emit_func_t ef = xecfg->hunk_func ? xdl_call_hunk_func : xdl_emit_diff; ++ ++ if (xdl_do_diff(mf1, mf2, xpp, &xe) < 0) { ++ ++ return -1; ++ } ++ if (xdl_change_compact(&xe.xdf1, &xe.xdf2, xpp->flags) < 0 || ++ xdl_change_compact(&xe.xdf2, &xe.xdf1, xpp->flags) < 0 || ++ xdl_build_script(&xe, &xscr) < 0) { ++ ++ xdl_free_env(&xe); ++ return -1; ++ } ++ if (xscr) { ++ if (xpp->flags & XDF_IGNORE_BLANK_LINES) ++ xdl_mark_ignorable(xscr, &xe, xpp->flags); ++ ++ if (ef(&xe, xscr, ecb, xecfg) < 0) { ++ ++ xdl_free_script(xscr); ++ xdl_free_env(&xe); ++ return -1; ++ } ++ xdl_free_script(xscr); ++ } ++ xdl_free_env(&xe); ++ ++ return 0; ++ } +*** ../vim-8.1.0359/src/xdiff/xdiffi.h 1970-01-01 01:00:00.000000000 +0100 +--- src/xdiff/xdiffi.h 2018-09-10 17:39:20.324083781 +0200 +*************** +*** 0 **** +--- 1,64 ---- ++ /* ++ * LibXDiff by Davide Libenzi ( File Differential Library ) ++ * Copyright (C) 2003 Davide Libenzi ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, see ++ * <http://www.gnu.org/licenses/>. ++ * ++ * Davide Libenzi <davidel@xmailserver.org> ++ * ++ */ ++ ++ #if !defined(XDIFFI_H) ++ #define XDIFFI_H ++ ++ ++ typedef struct s_diffdata { ++ long nrec; ++ unsigned long const *ha; ++ long *rindex; ++ char *rchg; ++ } diffdata_t; ++ ++ typedef struct s_xdalgoenv { ++ long mxcost; ++ long snake_cnt; ++ long heur_min; ++ } xdalgoenv_t; ++ ++ typedef struct s_xdchange { ++ struct s_xdchange *next; ++ long i1, i2; ++ long chg1, chg2; ++ int ignore; ++ } xdchange_t; ++ ++ ++ ++ int xdl_recs_cmp(diffdata_t *dd1, long off1, long lim1, ++ diffdata_t *dd2, long off2, long lim2, ++ long *kvdf, long *kvdb, int need_min, xdalgoenv_t *xenv); ++ int xdl_do_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, ++ xdfenv_t *xe); ++ int xdl_change_compact(xdfile_t *xdf, xdfile_t *xdfo, long flags); ++ int xdl_build_script(xdfenv_t *xe, xdchange_t **xscr); ++ void xdl_free_script(xdchange_t *xscr); ++ int xdl_emit_diff(xdfenv_t *xe, xdchange_t *xscr, xdemitcb_t *ecb, ++ xdemitconf_t const *xecfg); ++ int xdl_do_patience_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, ++ xdfenv_t *env); ++ int xdl_do_histogram_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, ++ xdfenv_t *env); ++ ++ #endif /* #if !defined(XDIFFI_H) */ +*** ../vim-8.1.0359/src/xdiff/xemit.c 1970-01-01 01:00:00.000000000 +0100 +--- src/xdiff/xemit.c 2018-09-10 17:39:20.324083781 +0200 +*************** +*** 0 **** +--- 1,312 ---- ++ /* ++ * LibXDiff by Davide Libenzi ( File Differential Library ) ++ * Copyright (C) 2003 Davide Libenzi ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, see ++ * <http://www.gnu.org/licenses/>. ++ * ++ * Davide Libenzi <davidel@xmailserver.org> ++ * ++ */ ++ ++ #include "xinclude.h" ++ ++ static long xdl_get_rec(xdfile_t *xdf, long ri, char const **rec) { ++ ++ *rec = xdf->recs[ri]->ptr; ++ ++ return xdf->recs[ri]->size; ++ } ++ ++ ++ static int xdl_emit_record(xdfile_t *xdf, long ri, char const *pre, xdemitcb_t *ecb) { ++ long size, psize = strlen(pre); ++ char const *rec; ++ ++ size = xdl_get_rec(xdf, ri, &rec); ++ if (xdl_emit_diffrec(rec, size, pre, psize, ecb) < 0) { ++ ++ return -1; ++ } ++ ++ return 0; ++ } ++ ++ ++ /* ++ * Starting at the passed change atom, find the latest change atom to be included ++ * inside the differential hunk according to the specified configuration. ++ * Also advance xscr if the first changes must be discarded. ++ */ ++ xdchange_t *xdl_get_hunk(xdchange_t **xscr, xdemitconf_t const *xecfg) ++ { ++ xdchange_t *xch, *xchp, *lxch; ++ long max_common = 2 * xecfg->ctxlen + xecfg->interhunkctxlen; ++ long max_ignorable = xecfg->ctxlen; ++ unsigned long ignored = 0; /* number of ignored blank lines */ ++ ++ /* remove ignorable changes that are too far before other changes */ ++ for (xchp = *xscr; xchp && xchp->ignore; xchp = xchp->next) { ++ xch = xchp->next; ++ ++ if (xch == NULL || ++ xch->i1 - (xchp->i1 + xchp->chg1) >= max_ignorable) ++ *xscr = xch; ++ } ++ ++ if (*xscr == NULL) ++ return NULL; ++ ++ lxch = *xscr; ++ ++ for (xchp = *xscr, xch = xchp->next; xch; xchp = xch, xch = xch->next) { ++ long distance = xch->i1 - (xchp->i1 + xchp->chg1); ++ if (distance > max_common) ++ break; ++ ++ if (distance < max_ignorable && (!xch->ignore || lxch == xchp)) { ++ lxch = xch; ++ ignored = 0; ++ } else if (distance < max_ignorable && xch->ignore) { ++ ignored += xch->chg2; ++ } else if (lxch != xchp && ++ xch->i1 + (long)ignored - (lxch->i1 + lxch->chg1) > max_common) { ++ break; ++ } else if (!xch->ignore) { ++ lxch = xch; ++ ignored = 0; ++ } else { ++ ignored += xch->chg2; ++ } ++ } ++ ++ return lxch; ++ } ++ ++ ++ static long def_ff(const char *rec, long len, char *buf, long sz, void *priv UNUSED) ++ { ++ if (len > 0 && ++ (isalpha((unsigned char)*rec) || /* identifier? */ ++ *rec == '_' || /* also identifier? */ ++ *rec == '$')) { /* identifiers from VMS and other esoterico */ ++ if (len > sz) ++ len = sz; ++ while (0 < len && isspace((unsigned char)rec[len - 1])) ++ len--; ++ memcpy(buf, rec, len); ++ return len; ++ } ++ return -1; ++ } ++ ++ static long match_func_rec(xdfile_t *xdf, xdemitconf_t const *xecfg, long ri, ++ char *buf, long sz) ++ { ++ const char *rec; ++ long len = xdl_get_rec(xdf, ri, &rec); ++ if (!xecfg->find_func) ++ return def_ff(rec, len, buf, sz, xecfg->find_func_priv); ++ return xecfg->find_func(rec, len, buf, sz, xecfg->find_func_priv); ++ } ++ ++ static int is_func_rec(xdfile_t *xdf, xdemitconf_t const *xecfg, long ri) ++ { ++ char dummy[1]; ++ return match_func_rec(xdf, xecfg, ri, dummy, sizeof(dummy)) >= 0; ++ } ++ ++ struct func_line { ++ long len; ++ char buf[80]; ++ }; ++ ++ static long get_func_line(xdfenv_t *xe, xdemitconf_t const *xecfg, ++ struct func_line *func_line, long start, long limit) ++ { ++ long l, size, step = (start > limit) ? -1 : 1; ++ char *buf, dummy[1]; ++ ++ buf = func_line ? func_line->buf : dummy; ++ size = func_line ? sizeof(func_line->buf) : sizeof(dummy); ++ ++ for (l = start; l != limit && 0 <= l && l < xe->xdf1.nrec; l += step) { ++ long len = match_func_rec(&xe->xdf1, xecfg, l, buf, size); ++ if (len >= 0) { ++ if (func_line) ++ func_line->len = len; ++ return l; ++ } ++ } ++ return -1; ++ } ++ ++ static int is_empty_rec(xdfile_t *xdf, long ri) ++ { ++ const char *rec; ++ long len = xdl_get_rec(xdf, ri, &rec); ++ ++ while (len > 0 && XDL_ISSPACE(*rec)) { ++ rec++; ++ len--; ++ } ++ return !len; ++ } ++ ++ int xdl_emit_diff(xdfenv_t *xe, xdchange_t *xscr, xdemitcb_t *ecb, ++ xdemitconf_t const *xecfg) { ++ long s1, s2, e1, e2, lctx; ++ xdchange_t *xch, *xche; ++ long funclineprev = -1; ++ struct func_line func_line = { 0 }; ++ ++ for (xch = xscr; xch; xch = xche->next) { ++ xche = xdl_get_hunk(&xch, xecfg); ++ if (!xch) ++ break; ++ ++ s1 = XDL_MAX(xch->i1 - xecfg->ctxlen, 0); ++ s2 = XDL_MAX(xch->i2 - xecfg->ctxlen, 0); ++ ++ if (xecfg->flags & XDL_EMIT_FUNCCONTEXT) { ++ long fs1, i1 = xch->i1; ++ ++ /* Appended chunk? */ ++ if (i1 >= xe->xdf1.nrec) { ++ long i2 = xch->i2; ++ ++ /* ++ * We don't need additional context if ++ * a whole function was added. ++ */ ++ while (i2 < xe->xdf2.nrec) { ++ if (is_func_rec(&xe->xdf2, xecfg, i2)) ++ goto post_context_calculation; ++ i2++; ++ } ++ ++ /* ++ * Otherwise get more context from the ++ * pre-image. ++ */ ++ i1 = xe->xdf1.nrec - 1; ++ } ++ ++ fs1 = get_func_line(xe, xecfg, NULL, i1, -1); ++ while (fs1 > 0 && !is_empty_rec(&xe->xdf1, fs1 - 1) && ++ !is_func_rec(&xe->xdf1, xecfg, fs1 - 1)) ++ fs1--; ++ if (fs1 < 0) ++ fs1 = 0; ++ if (fs1 < s1) { ++ s2 -= s1 - fs1; ++ s1 = fs1; ++ } ++ } ++ ++ post_context_calculation: ++ lctx = xecfg->ctxlen; ++ lctx = XDL_MIN(lctx, xe->xdf1.nrec - (xche->i1 + xche->chg1)); ++ lctx = XDL_MIN(lctx, xe->xdf2.nrec - (xche->i2 + xche->chg2)); ++ ++ e1 = xche->i1 + xche->chg1 + lctx; ++ e2 = xche->i2 + xche->chg2 + lctx; ++ ++ if (xecfg->flags & XDL_EMIT_FUNCCONTEXT) { ++ long fe1 = get_func_line(xe, xecfg, NULL, ++ xche->i1 + xche->chg1, ++ xe->xdf1.nrec); ++ while (fe1 > 0 && is_empty_rec(&xe->xdf1, fe1 - 1)) ++ fe1--; ++ if (fe1 < 0) ++ fe1 = xe->xdf1.nrec; ++ if (fe1 > e1) { ++ e2 += fe1 - e1; ++ e1 = fe1; ++ } ++ ++ /* ++ * Overlap with next change? Then include it ++ * in the current hunk and start over to find ++ * its new end. ++ */ ++ if (xche->next) { ++ long l = XDL_MIN(xche->next->i1, ++ xe->xdf1.nrec - 1); ++ if (l - xecfg->ctxlen <= e1 || ++ get_func_line(xe, xecfg, NULL, l, e1) < 0) { ++ xche = xche->next; ++ goto post_context_calculation; ++ } ++ } ++ } ++ ++ /* ++ * Emit current hunk header. ++ */ ++ ++ if (xecfg->flags & XDL_EMIT_FUNCNAMES) { ++ get_func_line(xe, xecfg, &func_line, ++ s1 - 1, funclineprev); ++ funclineprev = s1 - 1; ++ } ++ if (xdl_emit_hunk_hdr(s1 + 1, e1 - s1, s2 + 1, e2 - s2, ++ func_line.buf, func_line.len, ecb) < 0) ++ return -1; ++ ++ /* ++ * Emit pre-context. ++ */ ++ for (; s2 < xch->i2; s2++) ++ if (xdl_emit_record(&xe->xdf2, s2, " ", ecb) < 0) ++ return -1; ++ ++ for (s1 = xch->i1, s2 = xch->i2;; xch = xch->next) { ++ /* ++ * Merge previous with current change atom. ++ */ ++ for (; s1 < xch->i1 && s2 < xch->i2; s1++, s2++) ++ if (xdl_emit_record(&xe->xdf2, s2, " ", ecb) < 0) ++ return -1; ++ ++ /* ++ * Removes lines from the first file. ++ */ ++ for (s1 = xch->i1; s1 < xch->i1 + xch->chg1; s1++) ++ if (xdl_emit_record(&xe->xdf1, s1, "-", ecb) < 0) ++ return -1; ++ ++ /* ++ * Adds lines from the second file. ++ */ ++ for (s2 = xch->i2; s2 < xch->i2 + xch->chg2; s2++) ++ if (xdl_emit_record(&xe->xdf2, s2, "+", ecb) < 0) ++ return -1; ++ ++ if (xch == xche) ++ break; ++ s1 = xch->i1 + xch->chg1; ++ s2 = xch->i2 + xch->chg2; ++ } ++ ++ /* ++ * Emit post-context. ++ */ ++ for (s2 = xche->i2 + xche->chg2; s2 < e2; s2++) ++ if (xdl_emit_record(&xe->xdf2, s2, " ", ecb) < 0) ++ return -1; ++ } ++ ++ return 0; ++ } +*** ../vim-8.1.0359/src/xdiff/xemit.h 1970-01-01 01:00:00.000000000 +0100 +--- src/xdiff/xemit.h 2018-09-10 17:39:20.324083781 +0200 +*************** +*** 0 **** +--- 1,36 ---- ++ /* ++ * LibXDiff by Davide Libenzi ( File Differential Library ) ++ * Copyright (C) 2003 Davide Libenzi ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, see ++ * <http://www.gnu.org/licenses/>. ++ * ++ * Davide Libenzi <davidel@xmailserver.org> ++ * ++ */ ++ ++ #if !defined(XEMIT_H) ++ #define XEMIT_H ++ ++ ++ typedef int (*emit_func_t)(xdfenv_t *xe, xdchange_t *xscr, xdemitcb_t *ecb, ++ xdemitconf_t const *xecfg); ++ ++ xdchange_t *xdl_get_hunk(xdchange_t **xscr, xdemitconf_t const *xecfg); ++ int xdl_emit_diff(xdfenv_t *xe, xdchange_t *xscr, xdemitcb_t *ecb, ++ xdemitconf_t const *xecfg); ++ ++ ++ ++ #endif /* #if !defined(XEMIT_H) */ +*** ../vim-8.1.0359/src/xdiff/xhistogram.c 1970-01-01 01:00:00.000000000 +0100 +--- src/xdiff/xhistogram.c 2018-09-10 17:39:20.324083781 +0200 +*************** +*** 0 **** +--- 1,386 ---- ++ /* ++ * Copyright (C) 2010, Google Inc. ++ * and other copyright owners as documented in JGit's IP log. ++ * ++ * This program and the accompanying materials are made available ++ * under the terms of the Eclipse Distribution License v1.0 which ++ * accompanies this distribution, is reproduced below, and is ++ * available at http://www.eclipse.org/org/documents/edl-v10.php ++ * ++ * All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or ++ * without modification, are permitted provided that the following ++ * conditions are met: ++ * ++ * - Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * ++ * - Redistributions in binary form must reproduce the above ++ * copyright notice, this list of conditions and the following ++ * disclaimer in the documentation and/or other materials provided ++ * with the distribution. ++ * ++ * - Neither the name of the Eclipse Foundation, Inc. nor the ++ * names of its contributors may be used to endorse or promote ++ * products derived from this software without specific prior ++ * written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND ++ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, ++ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES ++ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR ++ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ++ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ++ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER ++ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ++ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ */ ++ ++ #include "xinclude.h" ++ #include "xtypes.h" ++ #include "xdiff.h" ++ ++ #define MAX_PTR INT_MAX ++ #define MAX_CNT INT_MAX ++ ++ #define LINE_END(n) (line##n + count##n - 1) ++ #define LINE_END_PTR(n) (*line##n + *count##n - 1) ++ ++ struct histindex { ++ struct record { ++ unsigned int ptr, cnt; ++ struct record *next; ++ } **records, /* an occurrence */ ++ **line_map; /* map of line to record chain */ ++ chastore_t rcha; ++ unsigned int *next_ptrs; ++ unsigned int table_bits, ++ records_size, ++ line_map_size; ++ ++ unsigned int max_chain_length, ++ key_shift, ++ ptr_shift; ++ ++ unsigned int cnt, ++ has_common; ++ ++ xdfenv_t *env; ++ xpparam_t const *xpp; ++ }; ++ ++ struct region { ++ unsigned int begin1, end1; ++ unsigned int begin2, end2; ++ }; ++ ++ #define LINE_MAP(i, a) (i->line_map[(a) - i->ptr_shift]) ++ ++ #define NEXT_PTR(index, ptr) \ ++ (index->next_ptrs[(ptr) - index->ptr_shift]) ++ ++ #define CNT(index, ptr) \ ++ ((LINE_MAP(index, ptr))->cnt) ++ ++ #define REC(env, s, l) \ ++ (env->xdf##s.recs[l - 1]) ++ ++ static int cmp_recs(xpparam_t const *xpp, ++ xrecord_t *r1, xrecord_t *r2) ++ { ++ return r1->ha == r2->ha && ++ xdl_recmatch(r1->ptr, r1->size, r2->ptr, r2->size, ++ xpp->flags); ++ } ++ ++ #define CMP_ENV(xpp, env, s1, l1, s2, l2) \ ++ (cmp_recs(xpp, REC(env, s1, l1), REC(env, s2, l2))) ++ ++ #define CMP(i, s1, l1, s2, l2) \ ++ (cmp_recs(i->xpp, REC(i->env, s1, l1), REC(i->env, s2, l2))) ++ ++ #define TABLE_HASH(index, side, line) \ ++ XDL_HASHLONG((REC(index->env, side, line))->ha, index->table_bits) ++ ++ static int scanA(struct histindex *index, int line1, int count1) ++ { ++ int ptr, tbl_idx; ++ unsigned int chain_len; ++ struct record **rec_chain, *rec; ++ ++ for (ptr = LINE_END(1); line1 <= ptr; ptr--) { ++ tbl_idx = TABLE_HASH(index, 1, ptr); ++ rec_chain = index->records + tbl_idx; ++ rec = *rec_chain; ++ ++ chain_len = 0; ++ while (rec) { ++ if (CMP(index, 1, rec->ptr, 1, ptr)) { ++ /* ++ * ptr is identical to another element. Insert ++ * it onto the front of the existing element ++ * chain. ++ */ ++ NEXT_PTR(index, ptr) = rec->ptr; ++ rec->ptr = ptr; ++ /* cap rec->cnt at MAX_CNT */ ++ rec->cnt = XDL_MIN(MAX_CNT, rec->cnt + 1); ++ LINE_MAP(index, ptr) = rec; ++ goto continue_scan; ++ } ++ ++ rec = rec->next; ++ chain_len++; ++ } ++ ++ if (chain_len == index->max_chain_length) ++ return -1; ++ ++ /* ++ * This is the first time we have ever seen this particular ++ * element in the sequence. Construct a new chain for it. ++ */ ++ if (!(rec = xdl_cha_alloc(&index->rcha))) ++ return -1; ++ rec->ptr = ptr; ++ rec->cnt = 1; ++ rec->next = *rec_chain; ++ *rec_chain = rec; ++ LINE_MAP(index, ptr) = rec; ++ ++ continue_scan: ++ ; /* no op */ ++ } ++ ++ return 0; ++ } ++ ++ static int try_lcs(struct histindex *index, struct region *lcs, int b_ptr, ++ int line1, int count1, int line2, int count2) ++ { ++ unsigned int b_next = b_ptr + 1; ++ struct record *rec = index->records[TABLE_HASH(index, 2, b_ptr)]; ++ unsigned int as, ae, bs, be, np, rc; ++ int should_break; ++ ++ for (; rec; rec = rec->next) { ++ if (rec->cnt > index->cnt) { ++ if (!index->has_common) ++ index->has_common = CMP(index, 1, rec->ptr, 2, b_ptr); ++ continue; ++ } ++ ++ as = rec->ptr; ++ if (!CMP(index, 1, as, 2, b_ptr)) ++ continue; ++ ++ index->has_common = 1; ++ for (;;) { ++ should_break = 0; ++ np = NEXT_PTR(index, as); ++ bs = b_ptr; ++ ae = as; ++ be = bs; ++ rc = rec->cnt; ++ ++ while (line1 < (int)as && line2 < (int)bs ++ && CMP(index, 1, as - 1, 2, bs - 1)) { ++ as--; ++ bs--; ++ if (1 < rc) ++ rc = XDL_MIN(rc, CNT(index, as)); ++ } ++ while ((int)ae < LINE_END(1) && (int)be < LINE_END(2) ++ && CMP(index, 1, ae + 1, 2, be + 1)) { ++ ae++; ++ be++; ++ if (1 < rc) ++ rc = XDL_MIN(rc, CNT(index, ae)); ++ } ++ ++ if (b_next <= be) ++ b_next = be + 1; ++ if (lcs->end1 - lcs->begin1 < ae - as || rc < index->cnt) { ++ lcs->begin1 = as; ++ lcs->begin2 = bs; ++ lcs->end1 = ae; ++ lcs->end2 = be; ++ index->cnt = rc; ++ } ++ ++ if (np == 0) ++ break; ++ ++ while (np <= ae) { ++ np = NEXT_PTR(index, np); ++ if (np == 0) { ++ should_break = 1; ++ break; ++ } ++ } ++ ++ if (should_break) ++ break; ++ ++ as = np; ++ } ++ } ++ return b_next; ++ } ++ ++ static int fall_back_to_classic_diff(xpparam_t const *xpp, xdfenv_t *env, ++ int line1, int count1, int line2, int count2) ++ { ++ xpparam_t xpparam; ++ xpparam.flags = xpp->flags & ~XDF_DIFF_ALGORITHM_MASK; ++ ++ return xdl_fall_back_diff(env, &xpparam, ++ line1, count1, line2, count2); ++ } ++ ++ static inline void free_index(struct histindex *index) ++ { ++ xdl_free(index->records); ++ xdl_free(index->line_map); ++ xdl_free(index->next_ptrs); ++ xdl_cha_free(&index->rcha); ++ } ++ ++ static int find_lcs(xpparam_t const *xpp, xdfenv_t *env, ++ struct region *lcs, ++ int line1, int count1, int line2, int count2) ++ { ++ int b_ptr; ++ int sz, ret = -1; ++ struct histindex index; ++ ++ memset(&index, 0, sizeof(index)); ++ ++ index.env = env; ++ index.xpp = xpp; ++ ++ index.records = NULL; ++ index.line_map = NULL; ++ /* in case of early xdl_cha_free() */ ++ index.rcha.head = NULL; ++ ++ index.table_bits = xdl_hashbits(count1); ++ sz = index.records_size = 1 << index.table_bits; ++ sz *= sizeof(struct record *); ++ if (!(index.records = (struct record **) xdl_malloc(sz))) ++ goto cleanup; ++ memset(index.records, 0, sz); ++ ++ sz = index.line_map_size = count1; ++ sz *= sizeof(struct record *); ++ if (!(index.line_map = (struct record **) xdl_malloc(sz))) ++ goto cleanup; ++ memset(index.line_map, 0, sz); ++ ++ sz = index.line_map_size; ++ sz *= sizeof(unsigned int); ++ if (!(index.next_ptrs = (unsigned int *) xdl_malloc(sz))) ++ goto cleanup; ++ memset(index.next_ptrs, 0, sz); ++ ++ /* lines / 4 + 1 comes from xprepare.c:xdl_prepare_ctx() */ ++ if (xdl_cha_init(&index.rcha, sizeof(struct record), count1 / 4 + 1) < 0) ++ goto cleanup; ++ ++ index.ptr_shift = line1; ++ index.max_chain_length = 64; ++ ++ if (scanA(&index, line1, count1)) ++ goto cleanup; ++ ++ index.cnt = index.max_chain_length + 1; ++ ++ for (b_ptr = line2; b_ptr <= LINE_END(2); ) ++ b_ptr = try_lcs(&index, lcs, b_ptr, line1, count1, line2, count2); ++ ++ if (index.has_common && index.max_chain_length < index.cnt) ++ ret = 1; ++ else ++ ret = 0; ++ ++ cleanup: ++ free_index(&index); ++ return ret; ++ } ++ ++ static int histogram_diff(xpparam_t const *xpp, xdfenv_t *env, ++ int line1, int count1, int line2, int count2) ++ { ++ struct region lcs; ++ int lcs_found; ++ int result; ++ redo: ++ result = -1; ++ ++ if (count1 <= 0 && count2 <= 0) ++ return 0; ++ ++ if (LINE_END(1) >= MAX_PTR) ++ return -1; ++ ++ if (!count1) { ++ while(count2--) ++ env->xdf2.rchg[line2++ - 1] = 1; ++ return 0; ++ } else if (!count2) { ++ while(count1--) ++ env->xdf1.rchg[line1++ - 1] = 1; ++ return 0; ++ } ++ ++ memset(&lcs, 0, sizeof(lcs)); ++ lcs_found = find_lcs(xpp, env, &lcs, line1, count1, line2, count2); ++ if (lcs_found < 0) ++ goto out; ++ else if (lcs_found) ++ result = fall_back_to_classic_diff(xpp, env, line1, count1, line2, count2); ++ else { ++ if (lcs.begin1 == 0 && lcs.begin2 == 0) { ++ while (count1--) ++ env->xdf1.rchg[line1++ - 1] = 1; ++ while (count2--) ++ env->xdf2.rchg[line2++ - 1] = 1; ++ result = 0; ++ } else { ++ result = histogram_diff(xpp, env, ++ line1, lcs.begin1 - line1, ++ line2, lcs.begin2 - line2); ++ if (result) ++ goto out; ++ /* ++ * result = histogram_diff(xpp, env, ++ * lcs.end1 + 1, LINE_END(1) - lcs.end1, ++ * lcs.end2 + 1, LINE_END(2) - lcs.end2); ++ * but let's optimize tail recursion ourself: ++ */ ++ count1 = LINE_END(1) - lcs.end1; ++ line1 = lcs.end1 + 1; ++ count2 = LINE_END(2) - lcs.end2; ++ line2 = lcs.end2 + 1; ++ goto redo; ++ } ++ } ++ out: ++ return result; ++ } ++ ++ int xdl_do_histogram_diff(mmfile_t *file1, mmfile_t *file2, ++ xpparam_t const *xpp, xdfenv_t *env) ++ { ++ if (xdl_prepare_env(file1, file2, xpp, env) < 0) ++ return -1; ++ ++ return histogram_diff(xpp, env, ++ env->xdf1.dstart + 1, env->xdf1.dend - env->xdf1.dstart + 1, ++ env->xdf2.dstart + 1, env->xdf2.dend - env->xdf2.dstart + 1); ++ } +*** ../vim-8.1.0359/src/xdiff/xinclude.h 1970-01-01 01:00:00.000000000 +0100 +--- src/xdiff/xinclude.h 2018-09-10 17:39:20.324083781 +0200 +*************** +*** 0 **** +--- 1,61 ---- ++ /* ++ * LibXDiff by Davide Libenzi ( File Differential Library ) ++ * Copyright (C) 2003 Davide Libenzi ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, see ++ * <http://www.gnu.org/licenses/>. ++ * ++ * Davide Libenzi <davidel@xmailserver.org> ++ * ++ */ ++ ++ /* defines HAVE_ATTRIBUTE_UNUSED */ ++ #ifdef HAVE_CONFIG_H ++ # include "../auto/config.h" ++ #endif ++ ++ /* Mark unused function arguments with UNUSED, so that gcc -Wunused-parameter ++ * can be used to check for mistakes. */ ++ #ifdef HAVE_ATTRIBUTE_UNUSED ++ # define UNUSED __attribute__((unused)) ++ #else ++ # define UNUSED ++ #endif ++ ++ #if defined(_MSC_VER) ++ # define inline __inline ++ #endif ++ ++ #if !defined(XINCLUDE_H) ++ #define XINCLUDE_H ++ ++ #include <ctype.h> ++ #include <stdio.h> ++ #include <stdlib.h> ++ #if !defined(_WIN32) ++ #include <unistd.h> ++ #endif ++ #include <string.h> ++ #include <limits.h> ++ ++ #include "xmacros.h" ++ #include "xdiff.h" ++ #include "xtypes.h" ++ #include "xutils.h" ++ #include "xprepare.h" ++ #include "xdiffi.h" ++ #include "xemit.h" ++ ++ ++ #endif /* #if !defined(XINCLUDE_H) */ +*** ../vim-8.1.0359/src/xdiff/xmacros.h 1970-01-01 01:00:00.000000000 +0100 +--- src/xdiff/xmacros.h 2018-09-10 17:39:20.324083781 +0200 +*************** +*** 0 **** +--- 1,54 ---- ++ /* ++ * LibXDiff by Davide Libenzi ( File Differential Library ) ++ * Copyright (C) 2003 Davide Libenzi ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, see ++ * <http://www.gnu.org/licenses/>. ++ * ++ * Davide Libenzi <davidel@xmailserver.org> ++ * ++ */ ++ ++ #if !defined(XMACROS_H) ++ #define XMACROS_H ++ ++ ++ ++ ++ #define XDL_MIN(a, b) ((a) < (b) ? (a): (b)) ++ #define XDL_MAX(a, b) ((a) > (b) ? (a): (b)) ++ #define XDL_ABS(v) ((v) >= 0 ? (v): -(v)) ++ #define XDL_ISDIGIT(c) ((c) >= '0' && (c) <= '9') ++ #define XDL_ISSPACE(c) (isspace((unsigned char)(c))) ++ #define XDL_ADDBITS(v,b) ((v) + ((v) >> (b))) ++ #define XDL_MASKBITS(b) ((1UL << (b)) - 1) ++ #define XDL_HASHLONG(v,b) (XDL_ADDBITS((unsigned long)(v), b) & XDL_MASKBITS(b)) ++ #define XDL_PTRFREE(p) do { if (p) { xdl_free(p); (p) = NULL; } } while (0) ++ #define XDL_LE32_PUT(p, v) \ ++ do { \ ++ unsigned char *__p = (unsigned char *) (p); \ ++ *__p++ = (unsigned char) (v); \ ++ *__p++ = (unsigned char) ((v) >> 8); \ ++ *__p++ = (unsigned char) ((v) >> 16); \ ++ *__p = (unsigned char) ((v) >> 24); \ ++ } while (0) ++ #define XDL_LE32_GET(p, v) \ ++ do { \ ++ unsigned char const *__p = (unsigned char const *) (p); \ ++ (v) = (unsigned long) __p[0] | ((unsigned long) __p[1]) << 8 | \ ++ ((unsigned long) __p[2]) << 16 | ((unsigned long) __p[3]) << 24; \ ++ } while (0) ++ ++ ++ #endif /* #if !defined(XMACROS_H) */ +*** ../vim-8.1.0359/src/xdiff/xpatience.c 1970-01-01 01:00:00.000000000 +0100 +--- src/xdiff/xpatience.c 2018-09-10 17:39:20.324083781 +0200 +*************** +*** 0 **** +--- 1,390 ---- ++ /* ++ * LibXDiff by Davide Libenzi ( File Differential Library ) ++ * Copyright (C) 2003-2016 Davide Libenzi, Johannes E. Schindelin ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, see ++ * <http://www.gnu.org/licenses/>. ++ * ++ * Davide Libenzi <davidel@xmailserver.org> ++ * ++ */ ++ #include "xinclude.h" ++ #include "xtypes.h" ++ #include "xdiff.h" ++ ++ /* ++ * The basic idea of patience diff is to find lines that are unique in ++ * both files. These are intuitively the ones that we want to see as ++ * common lines. ++ * ++ * The maximal ordered sequence of such line pairs (where ordered means ++ * that the order in the sequence agrees with the order of the lines in ++ * both files) naturally defines an initial set of common lines. ++ * ++ * Now, the algorithm tries to extend the set of common lines by growing ++ * the line ranges where the files have identical lines. ++ * ++ * Between those common lines, the patience diff algorithm is applied ++ * recursively, until no unique line pairs can be found; these line ranges ++ * are handled by the well-known Myers algorithm. ++ */ ++ ++ #define NON_UNIQUE ULONG_MAX ++ ++ /* ++ * This is a hash mapping from line hash to line numbers in the first and ++ * second file. ++ */ ++ struct hashmap { ++ int nr, alloc; ++ struct entry { ++ unsigned long hash; ++ /* ++ * 0 = unused entry, 1 = first line, 2 = second, etc. ++ * line2 is NON_UNIQUE if the line is not unique ++ * in either the first or the second file. ++ */ ++ unsigned long line1, line2; ++ /* ++ * "next" & "previous" are used for the longest common ++ * sequence; ++ * initially, "next" reflects only the order in file1. ++ */ ++ struct entry *next, *previous; ++ ++ /* ++ * If 1, this entry can serve as an anchor. See ++ * Documentation/diff-options.txt for more information. ++ */ ++ unsigned anchor : 1; ++ } *entries, *first, *last; ++ /* were common records found? */ ++ unsigned long has_matches; ++ mmfile_t *file1, *file2; ++ xdfenv_t *env; ++ xpparam_t const *xpp; ++ }; ++ ++ static int is_anchor(xpparam_t const *xpp, const char *line) ++ { ++ size_t i; ++ for (i = 0; i < xpp->anchors_nr; i++) { ++ if (!strncmp(line, xpp->anchors[i], strlen(xpp->anchors[i]))) ++ return 1; ++ } ++ return 0; ++ } ++ ++ /* The argument "pass" is 1 for the first file, 2 for the second. */ ++ static void insert_record(xpparam_t const *xpp, int line, struct hashmap *map, ++ int pass) ++ { ++ xrecord_t **records = pass == 1 ? ++ map->env->xdf1.recs : map->env->xdf2.recs; ++ xrecord_t *record = records[line - 1], *other; ++ /* ++ * After xdl_prepare_env() (or more precisely, due to ++ * xdl_classify_record()), the "ha" member of the records (AKA lines) ++ * is _not_ the hash anymore, but a linearized version of it. In ++ * other words, the "ha" member is guaranteed to start with 0 and ++ * the second record's ha can only be 0 or 1, etc. ++ * ++ * So we multiply ha by 2 in the hope that the hashing was ++ * "unique enough". ++ */ ++ int index = (int)((record->ha << 1) % map->alloc); ++ ++ while (map->entries[index].line1) { ++ other = map->env->xdf1.recs[map->entries[index].line1 - 1]; ++ if (map->entries[index].hash != record->ha || ++ !xdl_recmatch(record->ptr, record->size, ++ other->ptr, other->size, ++ map->xpp->flags)) { ++ if (++index >= map->alloc) ++ index = 0; ++ continue; ++ } ++ if (pass == 2) ++ map->has_matches = 1; ++ if (pass == 1 || map->entries[index].line2) ++ map->entries[index].line2 = NON_UNIQUE; ++ else ++ map->entries[index].line2 = line; ++ return; ++ } ++ if (pass == 2) ++ return; ++ map->entries[index].line1 = line; ++ map->entries[index].hash = record->ha; ++ map->entries[index].anchor = is_anchor(xpp, map->env->xdf1.recs[line - 1]->ptr); ++ if (!map->first) ++ map->first = map->entries + index; ++ if (map->last) { ++ map->last->next = map->entries + index; ++ map->entries[index].previous = map->last; ++ } ++ map->last = map->entries + index; ++ map->nr++; ++ } ++ ++ /* ++ * This function has to be called for each recursion into the inter-hunk ++ * parts, as previously non-unique lines can become unique when being ++ * restricted to a smaller part of the files. ++ * ++ * It is assumed that env has been prepared using xdl_prepare(). ++ */ ++ static int fill_hashmap(mmfile_t *file1, mmfile_t *file2, ++ xpparam_t const *xpp, xdfenv_t *env, ++ struct hashmap *result, ++ int line1, int count1, int line2, int count2) ++ { ++ result->file1 = file1; ++ result->file2 = file2; ++ result->xpp = xpp; ++ result->env = env; ++ ++ /* We know exactly how large we want the hash map */ ++ result->alloc = count1 * 2; ++ result->entries = (struct entry *) ++ xdl_malloc(result->alloc * sizeof(struct entry)); ++ if (!result->entries) ++ return -1; ++ memset(result->entries, 0, result->alloc * sizeof(struct entry)); ++ ++ /* First, fill with entries from the first file */ ++ while (count1--) ++ insert_record(xpp, line1++, result, 1); ++ ++ /* Then search for matches in the second file */ ++ while (count2--) ++ insert_record(xpp, line2++, result, 2); ++ ++ return 0; ++ } ++ ++ /* ++ * Find the longest sequence with a smaller last element (meaning a smaller ++ * line2, as we construct the sequence with entries ordered by line1). ++ */ ++ static int binary_search(struct entry **sequence, int longest, ++ struct entry *entry) ++ { ++ int left = -1, right = longest; ++ ++ while (left + 1 < right) { ++ int middle = left + (right - left) / 2; ++ /* by construction, no two entries can be equal */ ++ if (sequence[middle]->line2 > entry->line2) ++ right = middle; ++ else ++ left = middle; ++ } ++ /* return the index in "sequence", _not_ the sequence length */ ++ return left; ++ } ++ ++ /* ++ * The idea is to start with the list of common unique lines sorted by ++ * the order in file1. For each of these pairs, the longest (partial) ++ * sequence whose last element's line2 is smaller is determined. ++ * ++ * For efficiency, the sequences are kept in a list containing exactly one ++ * item per sequence length: the sequence with the smallest last ++ * element (in terms of line2). ++ */ ++ static struct entry *find_longest_common_sequence(struct hashmap *map) ++ { ++ struct entry **sequence = xdl_malloc(map->nr * sizeof(struct entry *)); ++ int longest = 0, i; ++ struct entry *entry; ++ ++ /* ++ * If not -1, this entry in sequence must never be overridden. ++ * Therefore, overriding entries before this has no effect, so ++ * do not do that either. ++ */ ++ int anchor_i = -1; ++ ++ for (entry = map->first; entry; entry = entry->next) { ++ if (!entry->line2 || entry->line2 == NON_UNIQUE) ++ continue; ++ i = binary_search(sequence, longest, entry); ++ entry->previous = i < 0 ? NULL : sequence[i]; ++ ++i; ++ if (i <= anchor_i) ++ continue; ++ sequence[i] = entry; ++ if (entry->anchor) { ++ anchor_i = i; ++ longest = anchor_i + 1; ++ } else if (i == longest) { ++ longest++; ++ } ++ } ++ ++ /* No common unique lines were found */ ++ if (!longest) { ++ xdl_free(sequence); ++ return NULL; ++ } ++ ++ /* Iterate starting at the last element, adjusting the "next" members */ ++ entry = sequence[longest - 1]; ++ entry->next = NULL; ++ while (entry->previous) { ++ entry->previous->next = entry; ++ entry = entry->previous; ++ } ++ xdl_free(sequence); ++ return entry; ++ } ++ ++ static int match(struct hashmap *map, int line1, int line2) ++ { ++ xrecord_t *record1 = map->env->xdf1.recs[line1 - 1]; ++ xrecord_t *record2 = map->env->xdf2.recs[line2 - 1]; ++ return xdl_recmatch(record1->ptr, record1->size, ++ record2->ptr, record2->size, map->xpp->flags); ++ } ++ ++ static int patience_diff(mmfile_t *file1, mmfile_t *file2, ++ xpparam_t const *xpp, xdfenv_t *env, ++ int line1, int count1, int line2, int count2); ++ ++ static int walk_common_sequence(struct hashmap *map, struct entry *first, ++ int line1, int count1, int line2, int count2) ++ { ++ int end1 = line1 + count1, end2 = line2 + count2; ++ int next1, next2; ++ ++ for (;;) { ++ /* Try to grow the line ranges of common lines */ ++ if (first) { ++ next1 = first->line1; ++ next2 = first->line2; ++ while (next1 > line1 && next2 > line2 && ++ match(map, next1 - 1, next2 - 1)) { ++ next1--; ++ next2--; ++ } ++ } else { ++ next1 = end1; ++ next2 = end2; ++ } ++ while (line1 < next1 && line2 < next2 && ++ match(map, line1, line2)) { ++ line1++; ++ line2++; ++ } ++ ++ /* Recurse */ ++ if (next1 > line1 || next2 > line2) { ++ struct hashmap submap; ++ ++ memset(&submap, 0, sizeof(submap)); ++ if (patience_diff(map->file1, map->file2, ++ map->xpp, map->env, ++ line1, next1 - line1, ++ line2, next2 - line2)) ++ return -1; ++ } ++ ++ if (!first) ++ return 0; ++ ++ while (first->next && ++ first->next->line1 == first->line1 + 1 && ++ first->next->line2 == first->line2 + 1) ++ first = first->next; ++ ++ line1 = first->line1 + 1; ++ line2 = first->line2 + 1; ++ ++ first = first->next; ++ } ++ } ++ ++ static int fall_back_to_classic_diff(struct hashmap *map, ++ int line1, int count1, int line2, int count2) ++ { ++ xpparam_t xpp; ++ xpp.flags = map->xpp->flags & ~XDF_DIFF_ALGORITHM_MASK; ++ ++ return xdl_fall_back_diff(map->env, &xpp, ++ line1, count1, line2, count2); ++ } ++ ++ /* ++ * Recursively find the longest common sequence of unique lines, ++ * and if none was found, ask xdl_do_diff() to do the job. ++ * ++ * This function assumes that env was prepared with xdl_prepare_env(). ++ */ ++ static int patience_diff(mmfile_t *file1, mmfile_t *file2, ++ xpparam_t const *xpp, xdfenv_t *env, ++ int line1, int count1, int line2, int count2) ++ { ++ struct hashmap map; ++ struct entry *first; ++ int result = 0; ++ ++ /* trivial case: one side is empty */ ++ if (!count1) { ++ while(count2--) ++ env->xdf2.rchg[line2++ - 1] = 1; ++ return 0; ++ } else if (!count2) { ++ while(count1--) ++ env->xdf1.rchg[line1++ - 1] = 1; ++ return 0; ++ } ++ ++ memset(&map, 0, sizeof(map)); ++ if (fill_hashmap(file1, file2, xpp, env, &map, ++ line1, count1, line2, count2)) ++ return -1; ++ ++ /* are there any matching lines at all? */ ++ if (!map.has_matches) { ++ while(count1--) ++ env->xdf1.rchg[line1++ - 1] = 1; ++ while(count2--) ++ env->xdf2.rchg[line2++ - 1] = 1; ++ xdl_free(map.entries); ++ return 0; ++ } ++ ++ first = find_longest_common_sequence(&map); ++ if (first) ++ result = walk_common_sequence(&map, first, ++ line1, count1, line2, count2); ++ else ++ result = fall_back_to_classic_diff(&map, ++ line1, count1, line2, count2); ++ ++ xdl_free(map.entries); ++ return result; ++ } ++ ++ int xdl_do_patience_diff(mmfile_t *file1, mmfile_t *file2, ++ xpparam_t const *xpp, xdfenv_t *env) ++ { ++ if (xdl_prepare_env(file1, file2, xpp, env) < 0) ++ return -1; ++ ++ /* environment is cleaned up in xdl_diff() */ ++ return patience_diff(file1, file2, xpp, env, ++ 1, env->xdf1.nrec, 1, env->xdf2.nrec); ++ } +*** ../vim-8.1.0359/src/xdiff/xprepare.c 1970-01-01 01:00:00.000000000 +0100 +--- src/xdiff/xprepare.c 2018-09-10 17:39:20.324083781 +0200 +*************** +*** 0 **** +--- 1,483 ---- ++ /* ++ * LibXDiff by Davide Libenzi ( File Differential Library ) ++ * Copyright (C) 2003 Davide Libenzi ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, see ++ * <http://www.gnu.org/licenses/>. ++ * ++ * Davide Libenzi <davidel@xmailserver.org> ++ * ++ */ ++ ++ #include "xinclude.h" ++ ++ ++ #define XDL_KPDIS_RUN 4 ++ #define XDL_MAX_EQLIMIT 1024 ++ #define XDL_SIMSCAN_WINDOW 100 ++ #define XDL_GUESS_NLINES1 256 ++ #define XDL_GUESS_NLINES2 20 ++ ++ ++ typedef struct s_xdlclass { ++ struct s_xdlclass *next; ++ unsigned long ha; ++ char const *line; ++ long size; ++ long idx; ++ long len1, len2; ++ } xdlclass_t; ++ ++ typedef struct s_xdlclassifier { ++ unsigned int hbits; ++ long hsize; ++ xdlclass_t **rchash; ++ chastore_t ncha; ++ xdlclass_t **rcrecs; ++ long alloc; ++ long count; ++ long flags; ++ } xdlclassifier_t; ++ ++ ++ ++ ++ static int xdl_init_classifier(xdlclassifier_t *cf, long size, long flags); ++ static void xdl_free_classifier(xdlclassifier_t *cf); ++ static int xdl_classify_record(unsigned int pass, xdlclassifier_t *cf, xrecord_t **rhash, ++ unsigned int hbits, xrecord_t *rec); ++ static int xdl_prepare_ctx(unsigned int pass, mmfile_t *mf, long narec, xpparam_t const *xpp, ++ xdlclassifier_t *cf, xdfile_t *xdf); ++ static void xdl_free_ctx(xdfile_t *xdf); ++ static int xdl_clean_mmatch(char const *dis, long i, long s, long e); ++ static int xdl_cleanup_records(xdlclassifier_t *cf, xdfile_t *xdf1, xdfile_t *xdf2); ++ static int xdl_trim_ends(xdfile_t *xdf1, xdfile_t *xdf2); ++ static int xdl_optimize_ctxs(xdlclassifier_t *cf, xdfile_t *xdf1, xdfile_t *xdf2); ++ ++ ++ ++ ++ static int xdl_init_classifier(xdlclassifier_t *cf, long size, long flags) { ++ cf->flags = flags; ++ ++ cf->hbits = xdl_hashbits((unsigned int) size); ++ cf->hsize = 1 << cf->hbits; ++ ++ if (xdl_cha_init(&cf->ncha, sizeof(xdlclass_t), size / 4 + 1) < 0) { ++ ++ return -1; ++ } ++ if (!(cf->rchash = (xdlclass_t **) xdl_malloc(cf->hsize * sizeof(xdlclass_t *)))) { ++ ++ xdl_cha_free(&cf->ncha); ++ return -1; ++ } ++ memset(cf->rchash, 0, cf->hsize * sizeof(xdlclass_t *)); ++ ++ cf->alloc = size; ++ if (!(cf->rcrecs = (xdlclass_t **) xdl_malloc(cf->alloc * sizeof(xdlclass_t *)))) { ++ ++ xdl_free(cf->rchash); ++ xdl_cha_free(&cf->ncha); ++ return -1; ++ } ++ ++ cf->count = 0; ++ ++ return 0; ++ } ++ ++ ++ static void xdl_free_classifier(xdlclassifier_t *cf) { ++ ++ xdl_free(cf->rcrecs); ++ xdl_free(cf->rchash); ++ xdl_cha_free(&cf->ncha); ++ } ++ ++ ++ static int xdl_classify_record(unsigned int pass, xdlclassifier_t *cf, xrecord_t **rhash, ++ unsigned int hbits, xrecord_t *rec) { ++ long hi; ++ char const *line; ++ xdlclass_t *rcrec; ++ xdlclass_t **rcrecs; ++ ++ line = rec->ptr; ++ hi = (long) XDL_HASHLONG(rec->ha, cf->hbits); ++ for (rcrec = cf->rchash[hi]; rcrec; rcrec = rcrec->next) ++ if (rcrec->ha == rec->ha && ++ xdl_recmatch(rcrec->line, rcrec->size, ++ rec->ptr, rec->size, cf->flags)) ++ break; ++ ++ if (!rcrec) { ++ if (!(rcrec = xdl_cha_alloc(&cf->ncha))) { ++ ++ return -1; ++ } ++ rcrec->idx = cf->count++; ++ if (cf->count > cf->alloc) { ++ cf->alloc *= 2; ++ if (!(rcrecs = (xdlclass_t **) xdl_realloc(cf->rcrecs, cf->alloc * sizeof(xdlclass_t *)))) { ++ ++ return -1; ++ } ++ cf->rcrecs = rcrecs; ++ } ++ cf->rcrecs[rcrec->idx] = rcrec; ++ rcrec->line = line; ++ rcrec->size = rec->size; ++ rcrec->ha = rec->ha; ++ rcrec->len1 = rcrec->len2 = 0; ++ rcrec->next = cf->rchash[hi]; ++ cf->rchash[hi] = rcrec; ++ } ++ ++ (pass == 1) ? rcrec->len1++ : rcrec->len2++; ++ ++ rec->ha = (unsigned long) rcrec->idx; ++ ++ hi = (long) XDL_HASHLONG(rec->ha, hbits); ++ rec->next = rhash[hi]; ++ rhash[hi] = rec; ++ ++ return 0; ++ } ++ ++ ++ static int xdl_prepare_ctx(unsigned int pass, mmfile_t *mf, long narec, xpparam_t const *xpp, ++ xdlclassifier_t *cf, xdfile_t *xdf) { ++ unsigned int hbits; ++ long nrec, hsize, bsize; ++ unsigned long hav; ++ char const *blk, *cur, *top, *prev; ++ xrecord_t *crec; ++ xrecord_t **recs, **rrecs; ++ xrecord_t **rhash; ++ unsigned long *ha; ++ char *rchg; ++ long *rindex; ++ ++ ha = NULL; ++ rindex = NULL; ++ rchg = NULL; ++ rhash = NULL; ++ recs = NULL; ++ ++ if (xdl_cha_init(&xdf->rcha, sizeof(xrecord_t), narec / 4 + 1) < 0) ++ goto abort; ++ if (!(recs = (xrecord_t **) xdl_malloc(narec * sizeof(xrecord_t *)))) ++ goto abort; ++ ++ if (XDF_DIFF_ALG(xpp->flags) == XDF_HISTOGRAM_DIFF) ++ hbits = hsize = 0; ++ else { ++ hbits = xdl_hashbits((unsigned int) narec); ++ hsize = 1 << hbits; ++ if (!(rhash = (xrecord_t **) xdl_malloc(hsize * sizeof(xrecord_t *)))) ++ goto abort; ++ memset(rhash, 0, hsize * sizeof(xrecord_t *)); ++ } ++ ++ nrec = 0; ++ if ((cur = blk = xdl_mmfile_first(mf, &bsize)) != NULL) { ++ for (top = blk + bsize; cur < top; ) { ++ prev = cur; ++ hav = xdl_hash_record(&cur, top, xpp->flags); ++ if (nrec >= narec) { ++ narec *= 2; ++ if (!(rrecs = (xrecord_t **) xdl_realloc(recs, narec * sizeof(xrecord_t *)))) ++ goto abort; ++ recs = rrecs; ++ } ++ if (!(crec = xdl_cha_alloc(&xdf->rcha))) ++ goto abort; ++ crec->ptr = prev; ++ crec->size = (long) (cur - prev); ++ crec->ha = hav; ++ recs[nrec++] = crec; ++ ++ if ((XDF_DIFF_ALG(xpp->flags) != XDF_HISTOGRAM_DIFF) && ++ xdl_classify_record(pass, cf, rhash, hbits, crec) < 0) ++ goto abort; ++ } ++ } ++ ++ if (!(rchg = (char *) xdl_malloc((nrec + 2) * sizeof(char)))) ++ goto abort; ++ memset(rchg, 0, (nrec + 2) * sizeof(char)); ++ ++ if (!(rindex = (long *) xdl_malloc((nrec + 1) * sizeof(long)))) ++ goto abort; ++ if (!(ha = (unsigned long *) xdl_malloc((nrec + 1) * sizeof(unsigned long)))) ++ goto abort; ++ ++ xdf->nrec = nrec; ++ xdf->recs = recs; ++ xdf->hbits = hbits; ++ xdf->rhash = rhash; ++ xdf->rchg = rchg + 1; ++ xdf->rindex = rindex; ++ xdf->nreff = 0; ++ xdf->ha = ha; ++ xdf->dstart = 0; ++ xdf->dend = nrec - 1; ++ ++ return 0; ++ ++ abort: ++ xdl_free(ha); ++ xdl_free(rindex); ++ xdl_free(rchg); ++ xdl_free(rhash); ++ xdl_free(recs); ++ xdl_cha_free(&xdf->rcha); ++ return -1; ++ } ++ ++ ++ static void xdl_free_ctx(xdfile_t *xdf) { ++ ++ xdl_free(xdf->rhash); ++ xdl_free(xdf->rindex); ++ xdl_free(xdf->rchg - 1); ++ xdl_free(xdf->ha); ++ xdl_free(xdf->recs); ++ xdl_cha_free(&xdf->rcha); ++ } ++ ++ ++ int xdl_prepare_env(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, ++ xdfenv_t *xe) { ++ long enl1, enl2, sample; ++ xdlclassifier_t cf; ++ ++ memset(&cf, 0, sizeof(cf)); ++ ++ /* ++ * For histogram diff, we can afford a smaller sample size and ++ * thus a poorer estimate of the number of lines, as the hash ++ * table (rhash) won't be filled up/grown. The number of lines ++ * (nrecs) will be updated correctly anyway by ++ * xdl_prepare_ctx(). ++ */ ++ sample = (XDF_DIFF_ALG(xpp->flags) == XDF_HISTOGRAM_DIFF ++ ? XDL_GUESS_NLINES2 : XDL_GUESS_NLINES1); ++ ++ enl1 = xdl_guess_lines(mf1, sample) + 1; ++ enl2 = xdl_guess_lines(mf2, sample) + 1; ++ ++ if (XDF_DIFF_ALG(xpp->flags) != XDF_HISTOGRAM_DIFF && ++ xdl_init_classifier(&cf, enl1 + enl2 + 1, xpp->flags) < 0) ++ return -1; ++ ++ if (xdl_prepare_ctx(1, mf1, enl1, xpp, &cf, &xe->xdf1) < 0) { ++ ++ xdl_free_classifier(&cf); ++ return -1; ++ } ++ if (xdl_prepare_ctx(2, mf2, enl2, xpp, &cf, &xe->xdf2) < 0) { ++ ++ xdl_free_ctx(&xe->xdf1); ++ xdl_free_classifier(&cf); ++ return -1; ++ } ++ ++ if ((XDF_DIFF_ALG(xpp->flags) != XDF_PATIENCE_DIFF) && ++ (XDF_DIFF_ALG(xpp->flags) != XDF_HISTOGRAM_DIFF) && ++ xdl_optimize_ctxs(&cf, &xe->xdf1, &xe->xdf2) < 0) { ++ ++ xdl_free_ctx(&xe->xdf2); ++ xdl_free_ctx(&xe->xdf1); ++ xdl_free_classifier(&cf); ++ return -1; ++ } ++ ++ if (XDF_DIFF_ALG(xpp->flags) != XDF_HISTOGRAM_DIFF) ++ xdl_free_classifier(&cf); ++ ++ return 0; ++ } ++ ++ ++ void xdl_free_env(xdfenv_t *xe) { ++ ++ xdl_free_ctx(&xe->xdf2); ++ xdl_free_ctx(&xe->xdf1); ++ } ++ ++ ++ static int xdl_clean_mmatch(char const *dis, long i, long s, long e) { ++ long r, rdis0, rpdis0, rdis1, rpdis1; ++ ++ /* ++ * Limits the window the is examined during the similar-lines ++ * scan. The loops below stops when dis[i - r] == 1 (line that ++ * has no match), but there are corner cases where the loop ++ * proceed all the way to the extremities by causing huge ++ * performance penalties in case of big files. ++ */ ++ if (i - s > XDL_SIMSCAN_WINDOW) ++ s = i - XDL_SIMSCAN_WINDOW; ++ if (e - i > XDL_SIMSCAN_WINDOW) ++ e = i + XDL_SIMSCAN_WINDOW; ++ ++ /* ++ * Scans the lines before 'i' to find a run of lines that either ++ * have no match (dis[j] == 0) or have multiple matches (dis[j] > 1). ++ * Note that we always call this function with dis[i] > 1, so the ++ * current line (i) is already a multimatch line. ++ */ ++ for (r = 1, rdis0 = 0, rpdis0 = 1; (i - r) >= s; r++) { ++ if (!dis[i - r]) ++ rdis0++; ++ else if (dis[i - r] == 2) ++ rpdis0++; ++ else ++ break; ++ } ++ /* ++ * If the run before the line 'i' found only multimatch lines, we ++ * return 0 and hence we don't make the current line (i) discarded. ++ * We want to discard multimatch lines only when they appear in the ++ * middle of runs with nomatch lines (dis[j] == 0). ++ */ ++ if (rdis0 == 0) ++ return 0; ++ for (r = 1, rdis1 = 0, rpdis1 = 1; (i + r) <= e; r++) { ++ if (!dis[i + r]) ++ rdis1++; ++ else if (dis[i + r] == 2) ++ rpdis1++; ++ else ++ break; ++ } ++ /* ++ * If the run after the line 'i' found only multimatch lines, we ++ * return 0 and hence we don't make the current line (i) discarded. ++ */ ++ if (rdis1 == 0) ++ return 0; ++ rdis1 += rdis0; ++ rpdis1 += rpdis0; ++ ++ return rpdis1 * XDL_KPDIS_RUN < (rpdis1 + rdis1); ++ } ++ ++ ++ /* ++ * Try to reduce the problem complexity, discard records that have no ++ * matches on the other file. Also, lines that have multiple matches ++ * might be potentially discarded if they happear in a run of discardable. ++ */ ++ static int xdl_cleanup_records(xdlclassifier_t *cf, xdfile_t *xdf1, xdfile_t *xdf2) { ++ long i, nm, nreff, mlim; ++ xrecord_t **recs; ++ xdlclass_t *rcrec; ++ char *dis, *dis1, *dis2; ++ ++ if (!(dis = (char *) xdl_malloc(xdf1->nrec + xdf2->nrec + 2))) { ++ ++ return -1; ++ } ++ memset(dis, 0, xdf1->nrec + xdf2->nrec + 2); ++ dis1 = dis; ++ dis2 = dis1 + xdf1->nrec + 1; ++ ++ if ((mlim = xdl_bogosqrt(xdf1->nrec)) > XDL_MAX_EQLIMIT) ++ mlim = XDL_MAX_EQLIMIT; ++ for (i = xdf1->dstart, recs = &xdf1->recs[xdf1->dstart]; i <= xdf1->dend; i++, recs++) { ++ rcrec = cf->rcrecs[(*recs)->ha]; ++ nm = rcrec ? rcrec->len2 : 0; ++ dis1[i] = (nm == 0) ? 0: (nm >= mlim) ? 2: 1; ++ } ++ ++ if ((mlim = xdl_bogosqrt(xdf2->nrec)) > XDL_MAX_EQLIMIT) ++ mlim = XDL_MAX_EQLIMIT; ++ for (i = xdf2->dstart, recs = &xdf2->recs[xdf2->dstart]; i <= xdf2->dend; i++, recs++) { ++ rcrec = cf->rcrecs[(*recs)->ha]; ++ nm = rcrec ? rcrec->len1 : 0; ++ dis2[i] = (nm == 0) ? 0: (nm >= mlim) ? 2: 1; ++ } ++ ++ for (nreff = 0, i = xdf1->dstart, recs = &xdf1->recs[xdf1->dstart]; ++ i <= xdf1->dend; i++, recs++) { ++ if (dis1[i] == 1 || ++ (dis1[i] == 2 && !xdl_clean_mmatch(dis1, i, xdf1->dstart, xdf1->dend))) { ++ xdf1->rindex[nreff] = i; ++ xdf1->ha[nreff] = (*recs)->ha; ++ nreff++; ++ } else ++ xdf1->rchg[i] = 1; ++ } ++ xdf1->nreff = nreff; ++ ++ for (nreff = 0, i = xdf2->dstart, recs = &xdf2->recs[xdf2->dstart]; ++ i <= xdf2->dend; i++, recs++) { ++ if (dis2[i] == 1 || ++ (dis2[i] == 2 && !xdl_clean_mmatch(dis2, i, xdf2->dstart, xdf2->dend))) { ++ xdf2->rindex[nreff] = i; ++ xdf2->ha[nreff] = (*recs)->ha; ++ nreff++; ++ } else ++ xdf2->rchg[i] = 1; ++ } ++ xdf2->nreff = nreff; ++ ++ xdl_free(dis); ++ ++ return 0; ++ } ++ ++ ++ /* ++ * Early trim initial and terminal matching records. ++ */ ++ static int xdl_trim_ends(xdfile_t *xdf1, xdfile_t *xdf2) { ++ long i, lim; ++ xrecord_t **recs1, **recs2; ++ ++ recs1 = xdf1->recs; ++ recs2 = xdf2->recs; ++ for (i = 0, lim = XDL_MIN(xdf1->nrec, xdf2->nrec); i < lim; ++ i++, recs1++, recs2++) ++ if ((*recs1)->ha != (*recs2)->ha) ++ break; ++ ++ xdf1->dstart = xdf2->dstart = i; ++ ++ recs1 = xdf1->recs + xdf1->nrec - 1; ++ recs2 = xdf2->recs + xdf2->nrec - 1; ++ for (lim -= i, i = 0; i < lim; i++, recs1--, recs2--) ++ if ((*recs1)->ha != (*recs2)->ha) ++ break; ++ ++ xdf1->dend = xdf1->nrec - i - 1; ++ xdf2->dend = xdf2->nrec - i - 1; ++ ++ return 0; ++ } ++ ++ ++ static int xdl_optimize_ctxs(xdlclassifier_t *cf, xdfile_t *xdf1, xdfile_t *xdf2) { ++ ++ if (xdl_trim_ends(xdf1, xdf2) < 0 || ++ xdl_cleanup_records(cf, xdf1, xdf2) < 0) { ++ ++ return -1; ++ } ++ ++ return 0; ++ } +*** ../vim-8.1.0359/src/xdiff/xprepare.h 1970-01-01 01:00:00.000000000 +0100 +--- src/xdiff/xprepare.h 2018-09-10 17:39:20.324083781 +0200 +*************** +*** 0 **** +--- 1,34 ---- ++ /* ++ * LibXDiff by Davide Libenzi ( File Differential Library ) ++ * Copyright (C) 2003 Davide Libenzi ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, see ++ * <http://www.gnu.org/licenses/>. ++ * ++ * Davide Libenzi <davidel@xmailserver.org> ++ * ++ */ ++ ++ #if !defined(XPREPARE_H) ++ #define XPREPARE_H ++ ++ ++ ++ int xdl_prepare_env(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, ++ xdfenv_t *xe); ++ void xdl_free_env(xdfenv_t *xe); ++ ++ ++ ++ #endif /* #if !defined(XPREPARE_H) */ +*** ../vim-8.1.0359/src/xdiff/xtypes.h 1970-01-01 01:00:00.000000000 +0100 +--- src/xdiff/xtypes.h 2018-09-10 17:39:20.324083781 +0200 +*************** +*** 0 **** +--- 1,67 ---- ++ /* ++ * LibXDiff by Davide Libenzi ( File Differential Library ) ++ * Copyright (C) 2003 Davide Libenzi ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, see ++ * <http://www.gnu.org/licenses/>. ++ * ++ * Davide Libenzi <davidel@xmailserver.org> ++ * ++ */ ++ ++ #if !defined(XTYPES_H) ++ #define XTYPES_H ++ ++ ++ ++ typedef struct s_chanode { ++ struct s_chanode *next; ++ long icurr; ++ } chanode_t; ++ ++ typedef struct s_chastore { ++ chanode_t *head, *tail; ++ long isize, nsize; ++ chanode_t *ancur; ++ chanode_t *sncur; ++ long scurr; ++ } chastore_t; ++ ++ typedef struct s_xrecord { ++ struct s_xrecord *next; ++ char const *ptr; ++ long size; ++ unsigned long ha; ++ } xrecord_t; ++ ++ typedef struct s_xdfile { ++ chastore_t rcha; ++ long nrec; ++ unsigned int hbits; ++ xrecord_t **rhash; ++ long dstart, dend; ++ xrecord_t **recs; ++ char *rchg; ++ long *rindex; ++ long nreff; ++ unsigned long *ha; ++ } xdfile_t; ++ ++ typedef struct s_xdfenv { ++ xdfile_t xdf1, xdf2; ++ } xdfenv_t; ++ ++ ++ ++ #endif /* #if !defined(XTYPES_H) */ +*** ../vim-8.1.0359/src/xdiff/xutils.c 1970-01-01 01:00:00.000000000 +0100 +--- src/xdiff/xutils.c 2018-09-10 17:39:20.324083781 +0200 +*************** +*** 0 **** +--- 1,425 ---- ++ /* ++ * LibXDiff by Davide Libenzi ( File Differential Library ) ++ * Copyright (C) 2003 Davide Libenzi ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, see ++ * <http://www.gnu.org/licenses/>. ++ * ++ * Davide Libenzi <davidel@xmailserver.org> ++ * ++ */ ++ ++ #include <limits.h> ++ #include <assert.h> ++ #include "xinclude.h" ++ ++ ++ ++ ++ long xdl_bogosqrt(long n) { ++ long i; ++ ++ /* ++ * Classical integer square root approximation using shifts. ++ */ ++ for (i = 1; n > 0; n >>= 2) ++ i <<= 1; ++ ++ return i; ++ } ++ ++ ++ int xdl_emit_diffrec(char const *rec, long size, char const *pre, long psize, ++ xdemitcb_t *ecb) { ++ int i = 2; ++ mmbuffer_t mb[3]; ++ ++ mb[0].ptr = (char *) pre; ++ mb[0].size = psize; ++ mb[1].ptr = (char *) rec; ++ mb[1].size = size; ++ if (size > 0 && rec[size - 1] != '\n') { ++ mb[2].ptr = (char *) "\n\\ No newline at end of file\n"; ++ mb[2].size = strlen(mb[2].ptr); ++ i++; ++ } ++ if (ecb->outf(ecb->priv, mb, i) < 0) { ++ ++ return -1; ++ } ++ ++ return 0; ++ } ++ ++ void *xdl_mmfile_first(mmfile_t *mmf, long *size) ++ { ++ *size = mmf->size; ++ return mmf->ptr; ++ } ++ ++ ++ long xdl_mmfile_size(mmfile_t *mmf) ++ { ++ return mmf->size; ++ } ++ ++ ++ int xdl_cha_init(chastore_t *cha, long isize, long icount) { ++ ++ cha->head = cha->tail = NULL; ++ cha->isize = isize; ++ cha->nsize = icount * isize; ++ cha->ancur = cha->sncur = NULL; ++ cha->scurr = 0; ++ ++ return 0; ++ } ++ ++ ++ void xdl_cha_free(chastore_t *cha) { ++ chanode_t *cur, *tmp; ++ ++ for (cur = cha->head; (tmp = cur) != NULL;) { ++ cur = cur->next; ++ xdl_free(tmp); ++ } ++ } ++ ++ ++ void *xdl_cha_alloc(chastore_t *cha) { ++ chanode_t *ancur; ++ void *data; ++ ++ if (!(ancur = cha->ancur) || ancur->icurr == cha->nsize) { ++ if (!(ancur = (chanode_t *) xdl_malloc(sizeof(chanode_t) + cha->nsize))) { ++ ++ return NULL; ++ } ++ ancur->icurr = 0; ++ ancur->next = NULL; ++ if (cha->tail) ++ cha->tail->next = ancur; ++ if (!cha->head) ++ cha->head = ancur; ++ cha->tail = ancur; ++ cha->ancur = ancur; ++ } ++ ++ data = (char *) ancur + sizeof(chanode_t) + ancur->icurr; ++ ancur->icurr += cha->isize; ++ ++ return data; ++ } ++ ++ long xdl_guess_lines(mmfile_t *mf, long sample) { ++ long nl = 0, size, tsize = 0; ++ char const *data, *cur, *top; ++ ++ if ((cur = data = xdl_mmfile_first(mf, &size)) != NULL) { ++ for (top = data + size; nl < sample && cur < top; ) { ++ nl++; ++ if (!(cur = memchr(cur, '\n', top - cur))) ++ cur = top; ++ else ++ cur++; ++ } ++ tsize += (long) (cur - data); ++ } ++ ++ if (nl && tsize) ++ nl = xdl_mmfile_size(mf) / (tsize / nl); ++ ++ return nl + 1; ++ } ++ ++ int xdl_blankline(const char *line, long size, long flags) ++ { ++ long i; ++ ++ if (!(flags & XDF_WHITESPACE_FLAGS)) ++ return (size <= 1); ++ ++ for (i = 0; i < size && XDL_ISSPACE(line[i]); i++) ++ ; ++ ++ return (i == size); ++ } ++ ++ /* ++ * Have we eaten everything on the line, except for an optional ++ * CR at the very end? ++ */ ++ static int ends_with_optional_cr(const char *l, long s, long i) ++ { ++ int complete = s && l[s-1] == '\n'; ++ ++ if (complete) ++ s--; ++ if (s == i) ++ return 1; ++ /* do not ignore CR at the end of an incomplete line */ ++ if (complete && s == i + 1 && l[i] == '\r') ++ return 1; ++ return 0; ++ } ++ ++ int xdl_recmatch(const char *l1, long s1, const char *l2, long s2, long flags) ++ { ++ int i1, i2; ++ ++ if (s1 == s2 && !memcmp(l1, l2, s1)) ++ return 1; ++ if (!(flags & XDF_WHITESPACE_FLAGS)) ++ return 0; ++ ++ i1 = 0; ++ i2 = 0; ++ ++ /* ++ * -w matches everything that matches with -b, and -b in turn ++ * matches everything that matches with --ignore-space-at-eol, ++ * which in turn matches everything that matches with --ignore-cr-at-eol. ++ * ++ * Each flavor of ignoring needs different logic to skip whitespaces ++ * while we have both sides to compare. ++ */ ++ if (flags & XDF_IGNORE_WHITESPACE) { ++ goto skip_ws; ++ while (i1 < s1 && i2 < s2) { ++ if (l1[i1++] != l2[i2++]) ++ return 0; ++ skip_ws: ++ while (i1 < s1 && XDL_ISSPACE(l1[i1])) ++ i1++; ++ while (i2 < s2 && XDL_ISSPACE(l2[i2])) ++ i2++; ++ } ++ } else if (flags & XDF_IGNORE_WHITESPACE_CHANGE) { ++ while (i1 < s1 && i2 < s2) { ++ if (XDL_ISSPACE(l1[i1]) && XDL_ISSPACE(l2[i2])) { ++ /* Skip matching spaces and try again */ ++ while (i1 < s1 && XDL_ISSPACE(l1[i1])) ++ i1++; ++ while (i2 < s2 && XDL_ISSPACE(l2[i2])) ++ i2++; ++ continue; ++ } ++ if (l1[i1++] != l2[i2++]) ++ return 0; ++ } ++ } else if (flags & XDF_IGNORE_WHITESPACE_AT_EOL) { ++ while (i1 < s1 && i2 < s2 && l1[i1] == l2[i2]) { ++ i1++; ++ i2++; ++ } ++ } else if (flags & XDF_IGNORE_CR_AT_EOL) { ++ /* Find the first difference and see how the line ends */ ++ while (i1 < s1 && i2 < s2 && l1[i1] == l2[i2]) { ++ i1++; ++ i2++; ++ } ++ return (ends_with_optional_cr(l1, s1, i1) && ++ ends_with_optional_cr(l2, s2, i2)); ++ } ++ ++ /* ++ * After running out of one side, the remaining side must have ++ * nothing but whitespace for the lines to match. Note that ++ * ignore-whitespace-at-eol case may break out of the loop ++ * while there still are characters remaining on both lines. ++ */ ++ if (i1 < s1) { ++ while (i1 < s1 && XDL_ISSPACE(l1[i1])) ++ i1++; ++ if (s1 != i1) ++ return 0; ++ } ++ if (i2 < s2) { ++ while (i2 < s2 && XDL_ISSPACE(l2[i2])) ++ i2++; ++ return (s2 == i2); ++ } ++ return 1; ++ } ++ ++ static unsigned long xdl_hash_record_with_whitespace(char const **data, ++ char const *top, long flags) { ++ unsigned long ha = 5381; ++ char const *ptr = *data; ++ int cr_at_eol_only = (flags & XDF_WHITESPACE_FLAGS) == XDF_IGNORE_CR_AT_EOL; ++ ++ for (; ptr < top && *ptr != '\n'; ptr++) { ++ if (cr_at_eol_only) { ++ /* do not ignore CR at the end of an incomplete line */ ++ if (*ptr == '\r' && ++ (ptr + 1 < top && ptr[1] == '\n')) ++ continue; ++ } ++ else if (XDL_ISSPACE(*ptr)) { ++ const char *ptr2 = ptr; ++ int at_eol; ++ while (ptr + 1 < top && XDL_ISSPACE(ptr[1]) ++ && ptr[1] != '\n') ++ ptr++; ++ at_eol = (top <= ptr + 1 || ptr[1] == '\n'); ++ if (flags & XDF_IGNORE_WHITESPACE) ++ ; /* already handled */ ++ else if (flags & XDF_IGNORE_WHITESPACE_CHANGE ++ && !at_eol) { ++ ha += (ha << 5); ++ ha ^= (unsigned long) ' '; ++ } ++ else if (flags & XDF_IGNORE_WHITESPACE_AT_EOL ++ && !at_eol) { ++ while (ptr2 != ptr + 1) { ++ ha += (ha << 5); ++ ha ^= (unsigned long) *ptr2; ++ ptr2++; ++ } ++ } ++ continue; ++ } ++ ha += (ha << 5); ++ ha ^= (unsigned long) *ptr; ++ } ++ *data = ptr < top ? ptr + 1: ptr; ++ ++ return ha; ++ } ++ ++ unsigned long xdl_hash_record(char const **data, char const *top, long flags) { ++ unsigned long ha = 5381; ++ char const *ptr = *data; ++ ++ if (flags & XDF_WHITESPACE_FLAGS) ++ return xdl_hash_record_with_whitespace(data, top, flags); ++ ++ for (; ptr < top && *ptr != '\n'; ptr++) { ++ ha += (ha << 5); ++ ha ^= (unsigned long) *ptr; ++ } ++ *data = ptr < top ? ptr + 1: ptr; ++ ++ return ha; ++ } ++ ++ unsigned int xdl_hashbits(unsigned int size) { ++ unsigned int val = 1, bits = 0; ++ ++ for (; val < size && bits < CHAR_BIT * sizeof(unsigned int); val <<= 1, bits++); ++ return bits ? bits: 1; ++ } ++ ++ ++ int xdl_num_out(char *out, long val) { ++ char *ptr, *str = out; ++ char buf[32]; ++ ++ ptr = buf + sizeof(buf) - 1; ++ *ptr = '\0'; ++ if (val < 0) { ++ *--ptr = '-'; ++ val = -val; ++ } ++ for (; val && ptr > buf; val /= 10) ++ *--ptr = "0123456789"[val % 10]; ++ if (*ptr) ++ for (; *ptr; ptr++, str++) ++ *str = *ptr; ++ else ++ *str++ = '0'; ++ *str = '\0'; ++ ++ return str - out; ++ } ++ ++ int xdl_emit_hunk_hdr(long s1, long c1, long s2, long c2, ++ const char *func, long funclen, xdemitcb_t *ecb) { ++ int nb = 0; ++ mmbuffer_t mb; ++ char buf[128]; ++ ++ memcpy(buf, "@@ -", 4); ++ nb += 4; ++ ++ nb += xdl_num_out(buf + nb, c1 ? s1: s1 - 1); ++ ++ if (c1 != 1) { ++ memcpy(buf + nb, ",", 1); ++ nb += 1; ++ ++ nb += xdl_num_out(buf + nb, c1); ++ } ++ ++ memcpy(buf + nb, " +", 2); ++ nb += 2; ++ ++ nb += xdl_num_out(buf + nb, c2 ? s2: s2 - 1); ++ ++ if (c2 != 1) { ++ memcpy(buf + nb, ",", 1); ++ nb += 1; ++ ++ nb += xdl_num_out(buf + nb, c2); ++ } ++ ++ memcpy(buf + nb, " @@", 3); ++ nb += 3; ++ if (func && funclen) { ++ buf[nb++] = ' '; ++ if (funclen > (long)sizeof(buf) - nb - 1) ++ funclen = sizeof(buf) - nb - 1; ++ memcpy(buf + nb, func, funclen); ++ nb += funclen; ++ } ++ buf[nb++] = '\n'; ++ ++ mb.ptr = buf; ++ mb.size = nb; ++ if (ecb->outf(ecb->priv, &mb, 1) < 0) ++ return -1; ++ ++ return 0; ++ } ++ ++ int xdl_fall_back_diff(xdfenv_t *diff_env, xpparam_t const *xpp, ++ int line1, int count1, int line2, int count2) ++ { ++ /* ++ * This probably does not work outside Git, since ++ * we have a very simple mmfile structure. ++ * ++ * Note: ideally, we would reuse the prepared environment, but ++ * the libxdiff interface does not (yet) allow for diffing only ++ * ranges of lines instead of the whole files. ++ */ ++ mmfile_t subfile1, subfile2; ++ xdfenv_t env; ++ ++ subfile1.ptr = (char *)diff_env->xdf1.recs[line1 - 1]->ptr; ++ subfile1.size = diff_env->xdf1.recs[line1 + count1 - 2]->ptr + ++ diff_env->xdf1.recs[line1 + count1 - 2]->size - subfile1.ptr; ++ subfile2.ptr = (char *)diff_env->xdf2.recs[line2 - 1]->ptr; ++ subfile2.size = diff_env->xdf2.recs[line2 + count2 - 2]->ptr + ++ diff_env->xdf2.recs[line2 + count2 - 2]->size - subfile2.ptr; ++ if (xdl_do_diff(&subfile1, &subfile2, xpp, &env) < 0) ++ return -1; ++ ++ memcpy(diff_env->xdf1.rchg + line1 - 1, env.xdf1.rchg, count1); ++ memcpy(diff_env->xdf2.rchg + line2 - 1, env.xdf2.rchg, count2); ++ ++ xdl_free_env(&env); ++ ++ return 0; ++ } +*** ../vim-8.1.0359/src/xdiff/xutils.h 1970-01-01 01:00:00.000000000 +0100 +--- src/xdiff/xutils.h 2018-09-10 17:39:20.324083781 +0200 +*************** +*** 0 **** +--- 1,47 ---- ++ /* ++ * LibXDiff by Davide Libenzi ( File Differential Library ) ++ * Copyright (C) 2003 Davide Libenzi ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser General Public ++ * License along with this library; if not, see ++ * <http://www.gnu.org/licenses/>. ++ * ++ * Davide Libenzi <davidel@xmailserver.org> ++ * ++ */ ++ ++ #if !defined(XUTILS_H) ++ #define XUTILS_H ++ ++ ++ ++ long xdl_bogosqrt(long n); ++ int xdl_emit_diffrec(char const *rec, long size, char const *pre, long psize, ++ xdemitcb_t *ecb); ++ int xdl_cha_init(chastore_t *cha, long isize, long icount); ++ void xdl_cha_free(chastore_t *cha); ++ void *xdl_cha_alloc(chastore_t *cha); ++ long xdl_guess_lines(mmfile_t *mf, long sample); ++ int xdl_blankline(const char *line, long size, long flags); ++ int xdl_recmatch(const char *l1, long s1, const char *l2, long s2, long flags); ++ unsigned long xdl_hash_record(char const **data, char const *top, long flags); ++ unsigned int xdl_hashbits(unsigned int size); ++ int xdl_num_out(char *out, long val); ++ int xdl_emit_hunk_hdr(long s1, long c1, long s2, long c2, ++ const char *func, long funclen, xdemitcb_t *ecb); ++ int xdl_fall_back_diff(xdfenv_t *diff_env, xpparam_t const *xpp, ++ int line1, int count1, int line2, int count2); ++ ++ ++ ++ #endif /* #if !defined(XUTILS_H) */ +*** ../vim-8.1.0359/src/xdiff/README.txt 1970-01-01 01:00:00.000000000 +0100 +--- src/xdiff/README.txt 2018-09-10 17:39:20.324083781 +0200 +*************** +*** 0 **** +--- 1,14 ---- ++ The files in this directory come from the xdiff implementation in git. ++ You can find it here: https://github.com/git/git/tree/master/xdiff ++ The files were last updated 2018 September 10. ++ ++ This is originally based on libxdiff, which can be found here: ++ http://www.xmailserver.org/xdiff-lib.html ++ ++ The git version was used because it has been maintained and improved. ++ And since it's part of git it is expected to be reliable. ++ ++ The code is distributed under the GNU LGPL license. It is included in the ++ COPYING file. ++ ++ The first work for including xdiff in Vim was done by Christian Brabandt. +*** ../vim-8.1.0359/src/version.c 2018-09-09 22:02:21.165859748 +0200 +--- src/version.c 2018-09-10 17:23:11.443756983 +0200 +*************** +*** 796,797 **** +--- 796,799 ---- + { /* Add new patch number below this line */ ++ /**/ ++ 360, + /**/ + +-- +'Well, here's something to occupy you and keep your mind off things.' +'It won't work, I have an exceptionally large mind.' + -- Douglas Adams, "The Hitchhiker's Guide to the Galaxy" + + /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net \\\ +/// sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\ +\\\ an exciting new programming language -- http://www.Zimbu.org /// + \\\ help me help AIDS victims -- http://ICCF-Holland.org /// |