patch 9.1.1243: diff mode is lacking for changes within lines

Problem:  Diff mode's inline highlighting is lackluster. It only
          performs a line-by-line comparison, and calculates a single
          shortest range within a line that could encompass all the
          changes. In lines with multiple changes, or those that span
          multiple lines, this approach tends to end up highlighting
          much more than necessary.

Solution: Implement new inline highlighting modes by doing per-character
          or per-word diff within the diff block, and highlight only the
          relevant parts, add "inline:simple" to the defaults (which is
          the old behaviour)

This change introduces a new diffopt option "inline:<type>". Setting to
"none" will disable all inline highlighting, "simple" (the default) will
use the old behavior, "char" / "word" will perform a character/word-wise
diff of the texts within each diff block and only highlight the
differences.

The new char/word inline diff only use the internal xdiff, and will
respect diff options such as algorithm choice, icase, and misc iwhite
options. indent-heuristics is always on to perform better sliding.

For character highlight, a post-process of the diff results is first
applied before we show the highlight. This is because a naive diff will
create a result with a lot of small diff chunks and gaps, due to the
repetitive nature of individual characters. The post-process is a
heuristic-based refinement that attempts to merge adjacent diff blocks
if they are separated by a short gap (1-3 characters), and can be
further tuned in the future for better results. This process results in
more characters than necessary being highlighted but overall less visual
noise.

For word highlight, always use first buffer's iskeyword definition.
Otherwise if each buffer has different iskeyword settings we would not
be able to group words properly.

The char/word diffing is always per-diff block, not per line, meaning
that changes that span multiple lines will show up correctly.
Added/removed newlines are not shown by default, but if the user has
'list' set (with "eol" listchar defined), the eol character will be be
highlighted correctly for the specific newline characters.

Also, add a new "DiffTextAdd" highlight group linked to "DiffText" by
default. It allows color schemes to use different colors for texts that
have been added within a line versus modified.

This doesn't interact with linematch perfectly currently. The linematch
feature splits up diff blocks into multiple smaller blocks for better
visual matching, which makes inline highlight less useful especially for
multi-line change (e.g. a line is broken into two lines). This could be
addressed in the future.

As a side change, this also removes the bounds checking introduced to
diff_read() as they were added to mask existing logic bugs that were
properly fixed in #16768.

closes: #16881

Signed-off-by: Yee Cheng Chin <ychin.git@gmail.com>
Signed-off-by: Christian Brabandt <cb@256bit.org>

diff --git a/runtime/doc/diff.txt b/runtime/doc/diff.txt
index e3abbdeff5f6a227da3cdb0a6b7e87070e0b34a4..0dbc7f872e58392cf7ef3a1b766e00cbdcbd0145 100644 (file)
--- a/runtime/doc/diff.txt
+++ b/runtime/doc/diff.txt
@@ -1,4 +1,4 @@
-*diff.txt*      For Vim version 9.1.  Last change: 2024 Feb 01
+*diff.txt*      For Vim version 9.1.  Last change: 2024 Mar 26
 
 
                  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -226,14 +226,29 @@ The diffs are highlighted with these groups:
 |hl-DiffAdd|   DiffAdd         Added (inserted) lines.  These lines exist in
                                this buffer but not in another.
 |hl-DiffChange|        DiffChange      Changed lines.
-|hl-DiffText|  DiffText        Changed text inside a Changed line.  Vim
-                               finds the first character that is different,
-                               and the last character that is different
-                               (searching from the end of the line).  The
-                               text in between is highlighted.  This means
-                               that parts in the middle that are still the
-                               same are highlighted anyway.  The 'diffopt'
-                               flags "iwhite" and "icase" are used here.
+|hl-DiffText|  DiffText        Changed text inside a Changed line.  Exact
+                               behavior depends on the `inline:` setting in
+                               'diffopt'.
+                               With `inline:` set to "simple", Vim finds the
+                               first character that is different, and the
+                               last character that is different (searching
+                               from the end of the line).  The text in
+                               between is highlighted.  This means that parts
+                               in the middle that are still the same are
+                               highlighted anyway.  The 'diffopt' flags
+                               "iwhite" and "icase" are used here.
+                               With `inline:` set to "char" or "word", Vim
+                               uses the internal diff library to perform a
+                               detailed diff between the changed blocks and
+                               highlight the exact difference between the
+                               two.  Will respect any 'diffopt' flag that
+                               affects internal diff.
+                               Not used when `inline:` set to "none".
+|hl-DiffTextAdd|  DiffTextAdd  Added text inside a Changed line. Similar to
+                               DiffText, but used when there is no
+                               corresponding text in other buffers.  Will not
+                               be used when `inline:` is set to "simple" or
+                               "none".
 |hl-DiffDelete|        DiffDelete      Deleted lines.  Also called filler lines,
                                because they don't really exist in this
                                buffer.

diff --git a/runtime/doc/options.txt b/runtime/doc/options.txt
index a82453626fdae4d34948eac64f65bdc656db3bdb..035f6f74f40e85c9af8ac197e215aae2da801286 100644 (file)
--- a/runtime/doc/options.txt
+++ b/runtime/doc/options.txt
@@ -1,4 +1,4 @@
-*options.txt*  For Vim version 9.1.  Last change: 2025 Mar 14
+*options.txt*  For Vim version 9.1.  Last change: 2025 Mar 26
 
 
                  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -2910,7 +2910,8 @@ A jump table for the options with a short description can be found at |Q_op|.
        security reasons.
 
                                                *'dip'* *'diffopt'*
-'diffopt' 'dip'                string  (default "internal,filler,closeoff")
+'diffopt' 'dip'                string  (default
+                                "internal,filler,closeoff,inline:simple")
                        global
                        {not available when compiled without the |+diff|
                        feature}
@@ -2975,6 +2976,21 @@ A jump table for the options with a short description can be found at |Q_op|.
                                Use the indent heuristic for the internal
                                diff library.
 
+               inline:{text}   Highlight inline differences within a change.
+                               See |view-diffs|.  Supported values are:
+
+                               none    Do not perform inline highlighting.
+                               simple  Highlight from first different
+                                       character to the last one in each
+                                       line. This is the default if nothing
+                                       is set.
+                               char    Use internal diff to perform a
+                                       character-wise diff and highlight the
+                                       difference.
+                               word    Use internal diff to perform a
+                                       |word|-wise diff and highlight the
+                                       difference.
+
                internal        Use the internal diff library.  This is
                                ignored when 'diffexpr' is set.  *E960*
                                When running out of memory when writing a
@@ -4392,10 +4408,10 @@ A jump table for the options with a short description can be found at |Q_op|.
                                     v:Visual,V:VisualNOS,w:WarningMsg,
                                     W:WildMenu,f:Folded,F:FoldColumn,
                                     A:DiffAdd,C:DiffChange,D:DiffDelete,
-                                    T:DiffText,>:SignColumn,-:Conceal,
-                                    B:SpellBad,P:SpellCap,R:SpellRare,
-                                    L:SpellLocal,+:Pmenu,=:PmenuSel,
-                                    k:PmenuMatch,<:PmenuMatchSel,
+                                    T:DiffText,E:DiffTextAdd,>:SignColumn,
+                                    -:Conceal,B:SpellBad,P:SpellCap,
+                                    R:SpellRare, L:SpellLocal,+:Pmenu,
+                                    =:PmenuSel, k:PmenuMatch,<:PmenuMatchSel,
                                     [:PmenuKind,]:PmenuKindSel,
                                     {:PmenuExtra,}:PmenuExtraSel,
                                     x:PmenuSbar,X:PmenuThumb,*:TabLine,
@@ -4447,7 +4463,8 @@ A jump table for the options with a short description can be found at |Q_op|.
        |hl-DiffAdd|     A  added line in diff mode
        |hl-DiffChange|  C  changed line in diff mode
        |hl-DiffDelete|  D  deleted line in diff mode
-       |hl-DiffText|    T  inserted text in diff mode
+       |hl-DiffText|    T  changed text in diff mode
+       |hl-DiffTextAdd|   E  inserted text in diff mode
        |hl-SignColumn|  >  column used for |signs|
        |hl-Conceal|     -  the placeholders used for concealed characters
                            (see 'conceallevel')

diff --git a/runtime/doc/syntax.txt b/runtime/doc/syntax.txt
index fe6865e17692363c6d08109ee23b1f1ecddf2b84..1a7452f93c51c928a78ddbe85df0f80d8bab838a 100644 (file)
--- a/runtime/doc/syntax.txt
+++ b/runtime/doc/syntax.txt
@@ -1,4 +1,4 @@
-*syntax.txt*   For Vim version 9.1.  Last change: 2025 Mar 21
+*syntax.txt*   For Vim version 9.1.  Last change: 2025 Mar 26
 
 
                  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -5832,6 +5832,9 @@ DiffChange        Diff mode: Changed line. |diff.txt|
 DiffDelete     Diff mode: Deleted line. |diff.txt|
                                                        *hl-DiffText*
 DiffText       Diff mode: Changed text within a changed line. |diff.txt|
+                                                       *hl-DiffTextAdd*
+DiffTextAdd    Diff mode: Added text within a changed line.  Linked to
+               |hl-DiffText| by default. |diff.txt|
                                                        *hl-EndOfBuffer*
 EndOfBuffer    Filler lines (~) after the last line in the buffer.
                By default, this is highlighted like |hl-NonText|.

diff --git a/runtime/doc/tags b/runtime/doc/tags
index a02d07e22f950ffe171314937b43b7f6b6e922be..5ff06d3f5f34c2b496bc144fe72d1cc3765941a3 100644 (file)
--- a/runtime/doc/tags
+++ b/runtime/doc/tags
@@ -8205,6 +8205,7 @@ hl-DiffAdd        syntax.txt      /*hl-DiffAdd*
 hl-DiffChange  syntax.txt      /*hl-DiffChange*
 hl-DiffDelete  syntax.txt      /*hl-DiffDelete*
 hl-DiffText    syntax.txt      /*hl-DiffText*
+hl-DiffTextAdd syntax.txt      /*hl-DiffTextAdd*
 hl-Directory   syntax.txt      /*hl-Directory*
 hl-EndOfBuffer syntax.txt      /*hl-EndOfBuffer*
 hl-ErrorMsg    syntax.txt      /*hl-ErrorMsg*

diff --git a/runtime/doc/version9.txt b/runtime/doc/version9.txt
index 4f0da43a342e35b8256f175d1847c46ef1d38e0d..5868598be01147e350e5162899a9f6c776bc0fb1 100644 (file)
--- a/runtime/doc/version9.txt
+++ b/runtime/doc/version9.txt
@@ -1,4 +1,4 @@
-*version9.txt*  For Vim version 9.1.  Last change: 2025 Mar 23
+*version9.txt*  For Vim version 9.1.  Last change: 2025 Mar 26
 
 
                  VIM REFERENCE MANUAL    by Bram Moolenaar
@@ -41553,6 +41553,16 @@ Enum support for Vim9 script |:enum|
 
 Support for protected _new() method
 
+Diff mode ~
+---------
+Include the "linematch" algorithm for the 'diffopt' setting.  This aligns
+changes between buffers on similar lines improving the diff highlighting in
+Vim
+
+Improve the diff highlighting for changes within a line.  Configurable using
+the "inline" sub option value for the 'diffopt' setting, with "inline:simple"
+being added to the default "diffopt" value (but this does not change how diff
+mode works).
                                                        *new-other-9.2*
 Other new features ~
 ------------------
@@ -41570,10 +41580,6 @@ Support highlighting the matched text and the completion kind for insert-mode
 completion and command-line completion in |ins-completion-menu|, see
 |complete-items|
 
-Include the "linematch" algorithm for the 'diffopt' setting.  This aligns
-changes between buffers on similar lines improving the diff highlighting in
-Vim
-
 Support for the |Tuple| data type in Vim script and Vim9 script.
 
                                                        *changed-9.2*
@@ -41590,7 +41596,6 @@ Default values: ~
 - the default value of the 'keyprotocol' option has been updated and support
   for the ghostty terminal emulator (using kitty protocol) has been added
 
-
 Completion: ~
 - allow to complete directories from 'cdpath' for |:cd| and similar commands,
   add the "cd_in_path" completion type for e.g. |:command-complete| and
@@ -41702,7 +41707,8 @@ Autocommands: ~
 
 Highlighting: ~
 
-|hl-ComplMatchIns|     matched text of the currently inserted completion.
+|hl-ComplMatchIns|     matched text of the currently inserted completion
+|hl-DiffTextAdd|       added text within a changed line
 |hl-MsgArea|           highlighting of the Command-line and messages area
 |hl-PmenuMatch|                Popup menu: highlighting of matched text
 |hl-PmenuMatchSel|     Popup menu: highlighting of matched text in selected

diff --git a/runtime/syntax/vim.vim b/runtime/syntax/vim.vim
index 720038efb31b796d1c6db512bcdd83f2a4a43207..5027138075e7404fcc7c1e2e1fb8ab2afa386c58 100644 (file)
--- a/runtime/syntax/vim.vim
+++ b/runtime/syntax/vim.vim
@@ -123,7 +123,7 @@ syn keyword vimGroup contained      Comment Constant String Character Number Boolean
 
 " Default highlighting groups {{{2
 " GEN_SYN_VIM: vimHLGroup, START_STR='syn keyword vimHLGroup contained', END_STR=''
-syn keyword vimHLGroup contained ErrorMsg IncSearch ModeMsg NonText StatusLine StatusLineNC EndOfBuffer VertSplit VisualNOS DiffText PmenuSbar TabLineSel TabLineFill Cursor lCursor QuickFixLine CursorLineSign CursorLineFold CurSearch PmenuKind PmenuKindSel PmenuMatch PmenuMatchSel PmenuExtra PmenuExtraSel PopupSelected MessageWindow PopupNotification Normal Directory LineNr CursorLineNr MoreMsg Question Search SpellBad SpellCap SpellRare SpellLocal PmenuThumb Pmenu PmenuSel SpecialKey Title WarningMsg WildMenu Folded FoldColumn SignColumn Visual DiffAdd DiffChange DiffDelete TabLine CursorColumn CursorLine ColorColumn MatchParen StatusLineTerm StatusLineTermNC ToolbarLine ToolbarButton Menu Tooltip Scrollbar CursorIM LineNrAbove LineNrBelow
+syn keyword vimHLGroup contained ErrorMsg IncSearch ModeMsg NonText StatusLine StatusLineNC EndOfBuffer VertSplit VisualNOS DiffText DiffTextAdd PmenuSbar TabLineSel TabLineFill Cursor lCursor QuickFixLine CursorLineSign CursorLineFold CurSearch PmenuKind PmenuKindSel PmenuMatch PmenuMatchSel PmenuExtra PmenuExtraSel PopupSelected MessageWindow PopupNotification Normal Directory LineNr CursorLineNr MoreMsg Question Search SpellBad SpellCap SpellRare SpellLocal PmenuThumb Pmenu PmenuSel SpecialKey Title WarningMsg WildMenu Folded FoldColumn SignColumn Visual DiffAdd DiffChange DiffDelete TabLine CursorColumn CursorLine ColorColumn MatchParen StatusLineTerm StatusLineTermNC ToolbarLine ToolbarButton Menu Tooltip Scrollbar CursorIM LineNrAbove LineNrBelow
 syn match vimHLGroup contained "\<Conceal\>"
 syn case match
 

diff --git a/src/change.c b/src/change.c
index 05a6247f3141c517d8e51daaef37718953d744d7..5cddf9b340435a2bbb9ddf87ceb3312e3225d676 100644 (file)
--- a/src/change.c
+++ b/src/change.c
@@ -476,7 +476,10 @@ changed_common(
 #endif
 #ifdef FEAT_DIFF
     if (curwin->w_p_diff && diff_internal())
+    {
        curtab->tp_diff_update = TRUE;
+       diff_update_line(lnum);
+    }
 #endif
 
     // set the '. mark

diff --git a/src/diff.c b/src/diff.c
index 6e5097e4a8cc1307dbb71b6bb5cde55d9479c087..638aed94ee962685487d268b9b72c6947d8d9292 100644 (file)
--- a/src/diff.c
+++ b/src/diff.c
@@ -38,7 +38,13 @@ static int diff_need_update = FALSE; // ex_diffupdate needs to be called
 #define DIFF_CLOSE_OFF 0x400   // diffoff when closing window
 #define DIFF_FOLLOWWRAP        0x800   // follow the wrap option
 #define DIFF_LINEMATCH  0x1000  // match most similar lines within diff
+#define DIFF_INLINE_NONE    0x2000  // no inline highlight
+#define DIFF_INLINE_SIMPLE  0x4000  // inline highlight with simple algorithm
+#define DIFF_INLINE_CHAR    0x8000  // inline highlight with character diff
+#define DIFF_INLINE_WORD    0x10000 // inline highlight with word diff
 #define ALL_WHITE_DIFF (DIFF_IWHITE | DIFF_IWHITEALL | DIFF_IWHITEEOL)
+#define ALL_INLINE (DIFF_INLINE_NONE | DIFF_INLINE_SIMPLE | DIFF_INLINE_CHAR | DIFF_INLINE_WORD)
+#define ALL_INLINE_DIFF (DIFF_INLINE_CHAR | DIFF_INLINE_WORD)
 static int     diff_flags = DIFF_INTERNAL | DIFF_FILLER | DIFF_CLOSE_OFF;
 
 static long diff_algorithm = 0;
@@ -111,6 +117,13 @@ static int xdiff_out_unified(void *priv, mmbuffer_t *mb, int nbuf);
 #define FOR_ALL_DIFFBLOCKS_IN_TAB(tp, dp) \
     for ((dp) = (tp)->tp_first_diff; (dp) != NULL; (dp) = (dp)->df_next)
 
+    static void
+clear_diffblock(diff_T *dp)
+{
+    ga_clear(&dp->df_changes);
+    vim_free(dp);
+}
+
 /*
  * Called when deleting or unloading a buffer: No longer make a diff with it.
  */
@@ -511,7 +524,7 @@ diff_mark_adjust_tp(
                if (tp->tp_diffbuf[i] != NULL)
                    dprev->df_count[i] += dp->df_count[i];
            dprev->df_next = dp->df_next;
-           vim_free(dp);
+           clear_diffblock(dp);
            dp = dprev->df_next;
        }
        else
@@ -533,7 +546,7 @@ diff_mark_adjust_tp(
        if (i == DB_COUNT)
        {
            dnext = dp->df_next;
-           vim_free(dp);
+           clear_diffblock(dp);
            dp = dnext;
            if (dprev == NULL)
                tp->tp_first_diff = dnext;
@@ -569,7 +582,7 @@ diff_alloc_new(tabpage_T *tp, diff_T *dprev, diff_T *dp)
 {
     diff_T     *dnew;
 
-    dnew = ALLOC_ONE(diff_T);
+    dnew = ALLOC_CLEAR_ONE(diff_T);
     if (dnew == NULL)
        return NULL;
 
@@ -579,6 +592,9 @@ diff_alloc_new(tabpage_T *tp, diff_T *dprev, diff_T *dp)
        tp->tp_first_diff = dnew;
     else
        dprev->df_next = dnew;
+
+    dnew->has_changes = FALSE;
+    ga_init2(&dnew->df_changes, sizeof(diffline_change_T), 20);
     return dnew;
 }
 
@@ -805,6 +821,7 @@ diff_write_buffer(buf_T *buf, diffin_T *din, linenr_T start, linenr_T end)
            {
                int c;
                int     orig_len;
+               int     c_len = 1;
                char_u  cbuf[MB_MAXBYTES + 1];
 
                if (*s == NL)
@@ -813,14 +830,24 @@ diff_write_buffer(buf_T *buf, diffin_T *din, linenr_T start, linenr_T end)
                {
                    // xdiff doesn't support ignoring case, fold-case the text.
                    c = PTR2CHAR(s);
+                   c_len = MB_CHAR2LEN(c);
                    c = MB_CASEFOLD(c);
                }
                orig_len = mb_ptr2len(s);
-               if (mb_char2bytes(c, cbuf) != orig_len)
-                   // TODO: handle byte length difference
+               if (mb_char2bytes(c, cbuf) != c_len)
+                   // TODO: handle byte length difference.
+                   // One example is Å (3 bytes) and å (2 bytes).
                    mch_memmove(ptr + len, s, orig_len);
                else
-                   mch_memmove(ptr + len, cbuf, orig_len);
+               {
+                   mch_memmove(ptr + len, cbuf, c_len);
+                   if (orig_len > c_len)
+                   {
+                       // Copy remaining composing characters
+                       mch_memmove(ptr + len + c_len, s + c_len,
+                               orig_len - c_len);
+                   }
+               }
 
                s += orig_len;
                len += orig_len;
@@ -1663,7 +1690,7 @@ diff_read(
     diffio_T   *dio)           // diff output
 {
     FILE       *fd = NULL;
-    int                line_idx = 0;
+    int                line_hunk_idx = 0;  // line or hunk index
     diff_T     *dprev = NULL;
     diff_T     *dp = curtab->tp_first_diff;
     diff_T     *dn, *dpl;
@@ -1710,17 +1737,17 @@ diff_read(
     {
        if (dio->dio_internal)
        {
-           if (line_idx >= dout->dout_ga.ga_len)
-               break;      // did last line
-           hunk = ((diffhunk_T **)dout->dout_ga.ga_data)[line_idx++];
+           if (line_hunk_idx >= dout->dout_ga.ga_len)
+               break;      // did last hunk
+           hunk = ((diffhunk_T **)dout->dout_ga.ga_data)[line_hunk_idx++];
        }
        else
        {
            if (fd == NULL)
            {
-               if (line_idx >= dout->dout_ga.ga_len)
+               if (line_hunk_idx >= dout->dout_ga.ga_len)
                    break;          // did last line
-               line = ((char_u **)dout->dout_ga.ga_data)[line_idx++];
+               line = ((char_u **)dout->dout_ga.ga_data)[line_hunk_idx++];
            }
            else
            {
@@ -1842,10 +1869,6 @@ diff_read(
                    - (dp->df_lnum[idx_new] + dp->df_count[idx_new]);
                if (off > 0)
                    dp->df_count[idx_new] += off;
-               if ((dp->df_lnum[idx_new] + dp->df_count[idx_new] - 1)
-                       > curtab->tp_diffbuf[idx_new]->b_ml.ml_line_count)
-                   dp->df_count[idx_new] = curtab->tp_diffbuf[idx_new]->b_ml.ml_line_count
-                       - dp->df_lnum[idx_new] + 1;
            }
 
            // Adjust the size of the block to include all the lines to the
@@ -1864,10 +1887,6 @@ diff_read(
                    // overlap later.
                    dp->df_count[idx_new] += -off;
                }
-               if ((dp->df_lnum[idx_new] + dp->df_count[idx_new] - 1)
-                       > curtab->tp_diffbuf[idx_new]->b_ml.ml_line_count)
-                   dp->df_count[idx_new] = curtab->tp_diffbuf[idx_new]->b_ml.ml_line_count
-                       - dp->df_lnum[idx_new] + 1;
                off = 0;
            }
            for (i = idx_orig; i < idx_new; ++i)
@@ -1881,7 +1900,7 @@ diff_read(
            while (dn != dp->df_next)
            {
                dpl = dn->df_next;
-               vim_free(dn);
+               clear_diffblock(dn);
                dn = dpl;
            }
        }
@@ -1957,7 +1976,7 @@ diff_clear(tabpage_T *tp)
     for (p = tp->tp_first_diff; p != NULL; p = next_p)
     {
        next_p = p->df_next;
-       vim_free(p);
+       clear_diffblock(p);
     }
     tp->tp_first_diff = NULL;
 }
@@ -2818,6 +2837,37 @@ diffopt_changed(void)
            else
                return FAIL;
        }
+       else if (STRNCMP(p, "inline:", 7) == 0)
+       {
+           // Note: Keep this in sync with p_dip_inline_values.
+           p += 7;
+           if (STRNCMP(p, "none", 4) == 0)
+           {
+               p += 4;
+               diff_flags_new &= ~(ALL_INLINE);
+               diff_flags_new |= DIFF_INLINE_NONE;
+           }
+           else if (STRNCMP(p, "simple", 6) == 0)
+           {
+               p += 6;
+               diff_flags_new &= ~(ALL_INLINE);
+               diff_flags_new |= DIFF_INLINE_SIMPLE;
+           }
+           else if (STRNCMP(p, "char", 4) == 0)
+           {
+               p += 4;
+               diff_flags_new &= ~(ALL_INLINE);
+               diff_flags_new |= DIFF_INLINE_CHAR;
+           }
+           else if (STRNCMP(p, "word", 4) == 0)
+           {
+               p += 4;
+               diff_flags_new &= ~(ALL_INLINE);
+               diff_flags_new |= DIFF_INLINE_WORD;
+           }
+           else
+               return FAIL;
+       }
        else if (STRNCMP(p, "linematch:", 10) == 0 && VIM_ISDIGIT(p[10]))
        {
            p += 10;
@@ -2886,13 +2936,97 @@ diffopt_closeoff(void)
 }
 
 /*
- * Find the difference within a changed line.
- * Returns TRUE if the line was added, no other buffer has it.
+ * Called when a line has been updated. Used for updating inline diff in Insert
+ * mode without waiting for global diff update later.
+ */
+    void
+diff_update_line(linenr_T lnum)
+{
+    int                idx;
+    diff_T     *dp;
+
+    if (!(diff_flags & ALL_INLINE_DIFF))
+       // We only care if we are doing inline-diff where we cache the diff results
+       return;
+
+    idx = diff_buf_idx(curbuf);
+    if (idx == DB_COUNT)
+       return;
+    FOR_ALL_DIFFBLOCKS_IN_TAB(curtab, dp)
+       if (lnum <= dp->df_lnum[idx] + dp->df_count[idx])
+           break;
+
+    // clear the inline change cache as it's invalid
+    if (dp != NULL)
+    {
+       dp->has_changes = FALSE;
+       dp->df_changes.ga_len = 0;
+    }
+}
+
+static diffline_change_T simple_diffline_change; // used for simple inline diff algorithm
+
+/*
+ * Parse a diffline struct and returns the [start,end] byte offsets
+ *
+ * Returns TRUE if this change was added, no other buffer has it.
  */
     int
-diff_find_change(
+diff_change_parse(
+    diffline_T *diffline,
+    diffline_change_T *change,
+    int *change_start,
+    int *change_end)
+{
+    if (change->dc_start_lnum_off[diffline->bufidx] < diffline->lineoff)
+       *change_start = 0;
+    else
+       *change_start = change->dc_start[diffline->bufidx];
+    if (change->dc_end_lnum_off[diffline->bufidx] > diffline->lineoff)
+       *change_end = INT_MAX;
+    else
+       *change_end = change->dc_end[diffline->bufidx];
+
+    if (change == &simple_diffline_change)
+    {
+       // This is what we returned from simple inline diff. We always consider
+       // the range to be changed, rather than added for now.
+       return FALSE;
+    }
+
+    // Find out whether this is an addition. Note that for multi buffer diff,
+    // to tell whether lines are additions we check whether all the other diff
+    // lines are identical (in diff_check_with_linestatus). If so, we mark them
+    // as add. We don't do that for inline diff here for simplicity.
+    for (int i = 0; i < DB_COUNT; i++)
+    {
+       if (i == diffline->bufidx)
+           continue;
+       if (change->dc_start[i] != change->dc_end[i]
+               || change->dc_end_lnum_off[i] != change->dc_start_lnum_off[i])
+       {
+           return FALSE;
+       }
+    }
+    return TRUE;
+}
+
+/*
+ * Find the difference within a changed line and returns [startp,endp] byte
+ * positions.  Performs a simple algorithm by finding a single range in the
+ * middle.
+ *
+ * If diffopt has DIFF_INLINE_NONE set, then this will only calculate the return
+ * value (added or changed), but startp/endp will not be calculated.
+ *
+ * Returns TRUE if the line was added, no other buffer has it.
+ */
+    static int
+diff_find_change_simple(
     win_T      *wp,
     linenr_T   lnum,
+    diff_T     *dp,
+    int                idx,
     int                *startp,        // first char of the change
     int                *endp)          // last char of the change
 {
@@ -2901,40 +3035,22 @@ diff_find_change(
     int                i;
     int                si_org, si_new;
     int                ei_org, ei_new;
-    diff_T     *dp;
-    int                idx;
     int                off;
     int                added = TRUE;
     char_u     *p1, *p2;
     int                l;
 
-    // Make a copy of the line, the next ml_get() will invalidate it.
-    line_org = vim_strsave(ml_get_buf(wp->w_buffer, lnum, FALSE));
-    if (line_org == NULL)
-       return FALSE;
-
-    idx = diff_buf_idx(wp->w_buffer);
-    if (idx == DB_COUNT)       // cannot happen
-    {
-       vim_free(line_org);
-       return FALSE;
-    }
-
-    // search for a change that includes "lnum" in the list of diffblocks.
-    FOR_ALL_DIFFBLOCKS_IN_TAB(curtab, dp)
-       if (lnum <= dp->df_lnum[idx] + dp->df_count[idx])
-           break;
-    if (dp->is_linematched)
+    if (diff_flags & DIFF_INLINE_NONE)
     {
-       while (dp && dp->df_next
-                       && lnum == dp->df_count[idx] + dp->df_lnum[idx]
-                       && dp->df_next->df_lnum[idx] == lnum)
-           dp = dp->df_next;
+       // We only care about the return value, not the actual string comparisons.
+       line_org = NULL;
     }
-    if (dp == NULL || diff_check_sanity(curtab, dp) == FAIL)
+    else
     {
-       vim_free(line_org);
-       return FALSE;
+       // Make a copy of the line, the next ml_get() will invalidate it.
+       line_org = vim_strsave(ml_get_buf(wp->w_buffer, lnum, FALSE));
+       if (line_org == NULL)
+           return FALSE;
     }
 
     off = lnum - dp->df_lnum[idx];
@@ -2946,6 +3062,9 @@ diff_find_change(
            if (off >= dp->df_count[i])
                continue;
            added = FALSE;
+           if (diff_flags & DIFF_INLINE_NONE)
+               break; // early terminate as we only care about the return value
+
            line_new = ml_get_buf(curtab->tp_diffbuf[i],
                                                 dp->df_lnum[i] + off, FALSE);
 
@@ -3025,6 +3144,528 @@ diff_find_change(
     return added;
 }
 
+/*
+ * Mapping used for mapping from temporary mmfile created for inline diff back
+ * to original buffer's line/col.
+ */
+typedef struct
+{
+    long byte_start;
+    long num_bytes;
+    int lineoff;
+} linemap_entry_T;
+
+/*
+ * Refine inline character-wise diff blocks to create a more human readable
+ * highlight. Otherwise a naive diff under existing algorithms tends to create
+ * a messy output with lots of small gaps.
+ * It does this by merging adjacent long diff blocks if they are only separated
+ * by a couple characters.
+ * These are done by heuristics and can be further tuned.
+ */
+    static void
+diff_refine_inline_char_highlight(diff_T *dp_orig, garray_T *linemap, int idx1)
+{
+    // Perform multiple passes so that newly merged blocks will now be long
+    // enough which may cause other previously unmerged gaps to be merged as
+    // well.
+    int pass = 1;
+    do
+    {
+       int has_unmerged_gaps = FALSE;
+       int has_merged_gaps = FALSE;
+       diff_T *dp = dp_orig;
+       while (dp!= NULL && dp->df_next != NULL)
+       {
+           // Only use first buffer to calculate the gap because the gap is
+           // unchanged text, which would be the same in all buffers.
+           if (dp->df_lnum[idx1] + dp->df_count[idx1] - 1 >= linemap[idx1].ga_len
+                   || dp->df_next->df_lnum[idx1] - 1 >= linemap[idx1].ga_len)
+           {
+               dp = dp->df_next;
+               continue;
+           }
+
+           // If the gap occurs over different lines, don't consider it
+           linemap_entry_T *entry1 = &((linemap_entry_T*)linemap[idx1].ga_data)[dp->df_lnum[idx1] + dp->df_count[idx1] - 1];
+           linemap_entry_T *entry2 = &((linemap_entry_T*)linemap[idx1].ga_data)[dp->df_next->df_lnum[idx1] - 1];
+           if (entry1->lineoff != entry2->lineoff)
+           {
+               dp = dp->df_next;
+               continue;
+           }
+
+           linenr_T gap = dp->df_next->df_lnum[idx1] - (dp->df_lnum[idx1] + dp->df_count[idx1]);
+           if (gap <= 3)
+           {
+               linenr_T max_df_count = 0;
+               for (int i = 0; i < DB_COUNT; i++)
+                   max_df_count = MAX(max_df_count, dp->df_count[i] + dp->df_next->df_count[i]);
+
+               if (max_df_count >= gap * 4)
+               {
+                   // Merge current block with the next one. Don't advance the
+                   // pointer so we try the same merged block against the next
+                   // one.
+                   for (int i = 0; i < DB_COUNT; i++)
+                   {
+                       dp->df_count[i] = dp->df_next->df_lnum[i]
+                           + dp->df_next->df_count[i] - dp->df_lnum[i];
+                   }
+                   diff_T *dp_next = dp->df_next;
+                   dp->df_next = dp_next->df_next;
+                   clear_diffblock(dp_next);
+                   has_merged_gaps = TRUE;
+                   continue;
+               }
+               else
+                   has_unmerged_gaps = TRUE;
+           }
+           dp = dp->df_next;
+       }
+       if (!has_unmerged_gaps || !has_merged_gaps)
+           break;
+    } while (pass++ < 4); // use limited number of passes to avoid excessive looping
+}
+
+/*
+ * Find the inline difference within a diff block among differnt buffers.  Do
+ * this by splitting each block's content into characters or words, and then
+ * use internal xdiff to calculate the per-character/word diff.  The result is
+ * stored in dp instead of returned by the function.
+ */
+    static void
+diff_find_change_inline_diff(
+    diff_T     *dp)
+{
+    diffio_T   dio;
+    garray_T   linemap[DB_COUNT];
+    garray_T   file1_str;
+    garray_T   file2_str;
+    int                file1_idx = -1;
+
+    long       save_diff_algorithm = diff_algorithm;
+
+    CLEAR_FIELD(dio);
+    ga_init2(&dio.dio_diff.dout_ga, sizeof(char *), 1000);
+
+    // inline diff only supports internal algo
+    dio.dio_internal = TRUE;
+
+    // always use indent-heuristics to slide diff splits along
+    // whitespace
+    diff_algorithm |= XDF_INDENT_HEURISTIC;
+
+    // diff_read() has an implicit dependency on curtab->tp_first_diff
+    diff_T     *orig_diff = curtab->tp_first_diff;
+    curtab->tp_first_diff = NULL;
+
+    // Buffers to populate mmfile 1/2 that would be passed to xdiff as memory
+    // files. Use a grow array as it is not obvious how much exact space we
+    // need.
+    ga_init2(&file1_str, 1, 1024);
+    ga_init2(&file2_str, 1, 1024);
+
+    // Line map to map from generated mmfiles' line numbers back to original
+    // diff blocks' locations. Need this even for char diff because not all
+    // characters are 1-byte long / ASCII.
+    for (int i = 0; i < DB_COUNT; i++)
+       ga_init2(&linemap[i], sizeof(linemap_entry_T), 128);
+
+    for (int i = 0; i < DB_COUNT; i++)
+    {
+       dio.dio_diff.dout_ga.ga_len = 0;
+
+       buf_T *buf = curtab->tp_diffbuf[i];
+       if (buf == NULL || buf->b_ml.ml_mfp == NULL)
+           continue; // skip buffer that isn't loaded
+
+       if (dp->df_count[i] == 0)
+           continue; // skip buffer that don't have any texts in this block
+
+       if (file1_idx == -1)
+           file1_idx = i;
+
+       garray_T        *curstr = (file1_idx != i) ? &file2_str : &file1_str;
+
+       linenr_T numlines = 0;
+       curstr->ga_len = 0;
+
+       // Split each line into chars/words and populate fake file buffer as
+       // newline-delimited tokens as that's what xdiff requires.
+       for (int off = 0; off < dp->df_count[i]; off++)
+       {
+           char_u *curline = ml_get_buf(curtab->tp_diffbuf[i],
+                   dp->df_lnum[i] + off, FALSE);
+
+           int in_keyword = FALSE;
+
+           // iwhiteeol support vars
+           int last_white = FALSE;
+           int eol_ga_len = -1;
+           int eol_linemap_len = -1;
+           int eol_numlines = -1;
+
+           char_u *s;
+           for (s = curline; *s != NUL;)
+           {
+               // Always use the first buffer's 'iskeyword' to have a consistent diff
+               int new_in_keyword = FALSE;
+               if (diff_flags & DIFF_INLINE_WORD)
+                   new_in_keyword = vim_iswordp_buf(s, curtab->tp_diffbuf[file1_idx]);
+               if (in_keyword && !new_in_keyword)
+               {
+                   ga_append(curstr, NL);
+                   numlines++;
+               }
+
+               if (VIM_ISWHITE(*s))
+               {
+                   if (diff_flags & DIFF_IWHITEALL)
+                   {
+                       in_keyword = FALSE;
+                       s = skipwhite(s);
+                       continue;
+                   }
+                   else if ((diff_flags & DIFF_IWHITEEOL) || (diff_flags & DIFF_IWHITE))
+                   {
+                       if (!last_white)
+                       {
+                           eol_ga_len = curstr->ga_len;
+                           eol_linemap_len = linemap[i].ga_len;
+                           eol_numlines = numlines;
+                           last_white = TRUE;
+                       }
+                   }
+               }
+               else
+               {
+                   if ((diff_flags & DIFF_IWHITEEOL) || (diff_flags & DIFF_IWHITE))
+                   {
+                       last_white = FALSE;
+                       eol_ga_len = -1;
+                       eol_linemap_len = -1;
+                       eol_numlines = -1;
+                   }
+               }
+
+               int char_len = 1;
+               if (*s == NL)
+                   // NL is internal substitute for NUL
+                   ga_append(curstr, NUL);
+               else
+               {
+                   char_len = mb_ptr2len(s);
+
+                   if (VIM_ISWHITE(*s) && (diff_flags & DIFF_IWHITE))
+                       // Treat the entire white space span as a single char.
+                       char_len = skipwhite(s) - s;
+
+                   if (diff_flags & DIFF_ICASE)
+                   {
+                       int c;
+                       char_u cbuf[MB_MAXBYTES + 1];
+                       // xdiff doesn't support ignoring case, fold-case the text manually.
+                       c = PTR2CHAR(s);
+                       int c_len = MB_CHAR2LEN(c);
+                       c = MB_CASEFOLD(c);
+                       int c_fold_len = mb_char2bytes(c, cbuf);
+                       ga_concat_len(curstr, cbuf, c_fold_len);
+                       if (char_len > c_len)
+                       {
+                           // There may be remaining composing characters. Write those back in.
+                           // Composing characters don't need case folding.
+                           ga_concat_len(curstr, s + c_len, char_len - c_len);
+                       }
+                   }
+                   else
+                       ga_concat_len(curstr, s, char_len);
+               }
+
+               if (!new_in_keyword)
+               {
+                   ga_append(curstr, NL);
+                   numlines++;
+               }
+
+               if (!new_in_keyword || (new_in_keyword && !in_keyword))
+               {
+                   // create a new mapping entry from the xdiff mmfile back to
+                   // original line/col.
+                   linemap_entry_T linemap_entry;
+                   linemap_entry.lineoff = off;
+                   linemap_entry.byte_start = s - curline;
+                   linemap_entry.num_bytes = char_len;
+                   if (ga_grow(&linemap[i], 1) != OK)
+                       goto done;
+                   ((linemap_entry_T*)(linemap[i].ga_data))[linemap[i].ga_len]
+                       = linemap_entry;
+                   linemap[i].ga_len += 1;
+               }
+               else
+               {
+                   // Still inside a keyword. Just increment byte count but
+                   // don't make a new entry.
+                   // linemap always has at least one entry here
+                   ((linemap_entry_T*)linemap[i].ga_data)[linemap[i].ga_len-1].num_bytes
+                       += char_len;
+               }
+
+               in_keyword = new_in_keyword;
+               s += char_len;
+           }
+           if (in_keyword)
+           {
+               ga_append(curstr, NL);
+               numlines++;
+           }
+
+           if ((diff_flags & DIFF_IWHITEEOL) || (diff_flags & DIFF_IWHITE))
+           {
+               // Need to trim trailing whitespace. Do this simply by
+               // resetting arrays back to before we encountered them.
+               if (eol_ga_len != -1)
+               {
+                   curstr->ga_len = eol_ga_len;
+                   linemap[i].ga_len = eol_linemap_len;
+                   numlines = eol_numlines;
+               }
+           }
+
+           if (!(diff_flags & DIFF_IWHITEALL))
+           {
+               // Add an empty line token mapped to the end-of-line in the
+               // original file. This helps diff newline differences among
+               // files, which will be visualized when using 'list' as the eol
+               // listchar will be highlighted.
+               ga_append(curstr, NL);
+               numlines++;
+
+               linemap_entry_T linemap_entry;
+               linemap_entry.lineoff = off;
+               linemap_entry.byte_start = s - curline;
+               linemap_entry.num_bytes = sizeof(NL);
+               if (ga_grow(&linemap[i], 1) != OK)
+                   goto done;
+               ((linemap_entry_T*)(linemap[i].ga_data))[linemap[i].ga_len]
+                   = linemap_entry;
+               linemap[i].ga_len += 1;
+           }
+       }
+
+       if (file1_idx != i)
+       {
+           dio.dio_new.din_mmfile.ptr = (char *)curstr->ga_data;
+           dio.dio_new.din_mmfile.size = curstr->ga_len;
+       }
+       else
+       {
+           dio.dio_orig.din_mmfile.ptr = (char *)curstr->ga_data;
+           dio.dio_orig.din_mmfile.size = curstr->ga_len;
+       }
+       if (file1_idx != i)
+       {
+           // Perform diff with first file and read the results
+           int diff_status = diff_file_internal(&dio);
+           if (diff_status == FAIL)
+               goto done;
+
+           diff_read(0, i, &dio);
+           clear_diffout(&dio.dio_diff);
+       }
+    }
+    diff_T *new_diff = curtab->tp_first_diff;
+
+    if (diff_flags & DIFF_INLINE_CHAR && file1_idx != -1)
+       diff_refine_inline_char_highlight(new_diff, linemap, file1_idx);
+
+    // After the diff, use the linemap to obtain the original line/col of the
+    // changes and cache them in dp.
+    dp->df_changes.ga_len = 0; // this should already be zero
+    for (; new_diff != NULL; new_diff = new_diff->df_next)
+    {
+       diffline_change_T change;
+       CLEAR_FIELD(change);
+       for (int i = 0; i < DB_COUNT; i++)
+       {
+           if (new_diff->df_lnum[i] == 0)
+               continue;
+           linenr_T diff_lnum = new_diff->df_lnum[i] - 1; // use zero-index
+           linenr_T diff_lnum_end = diff_lnum + new_diff->df_count[i];
+
+           if (diff_lnum >= linemap[i].ga_len)
+           {
+               change.dc_start[i] = MAXCOL;
+               change.dc_start_lnum_off[i] = INT_MAX;
+           }
+           else
+           {
+               change.dc_start[i] = ((linemap_entry_T*)linemap[i].ga_data)[diff_lnum].byte_start;
+               change.dc_start_lnum_off[i] = ((linemap_entry_T*)linemap[i].ga_data)[diff_lnum].lineoff;
+           }
+
+           if (diff_lnum == diff_lnum_end)
+           {
+               change.dc_end[i] = change.dc_start[i];
+               change.dc_end_lnum_off[i] = change.dc_start_lnum_off[i];
+           }
+           else if (diff_lnum_end - 1 >= linemap[i].ga_len)
+           {
+               change.dc_end[i] = MAXCOL;
+               change.dc_end_lnum_off[i] = INT_MAX;
+           }
+           else
+           {
+               change.dc_end[i] = ((linemap_entry_T*)linemap[i].ga_data)[diff_lnum_end-1].byte_start +
+                   ((linemap_entry_T*)linemap[i].ga_data)[diff_lnum_end-1].num_bytes;
+               change.dc_end_lnum_off[i] = ((linemap_entry_T*)linemap[i].ga_data)[diff_lnum_end-1].lineoff;
+           }
+       }
+       if (ga_grow(&dp->df_changes, 1) != OK)
+       {
+           dp->df_changes.ga_len = 0;
+           goto done;
+       }
+       ((diffline_change_T*)(dp->df_changes.ga_data))[dp->df_changes.ga_len] = change;
+       dp->df_changes.ga_len += 1;
+    }
+
+done:
+    diff_algorithm = save_diff_algorithm;
+
+    dp->has_changes = TRUE;
+
+    diff_clear(curtab);
+    curtab->tp_first_diff = orig_diff;
+
+    ga_clear(&file1_str);
+    ga_clear(&file2_str);
+    // No need to clear dio.dio_orig/dio_new because they were referencing
+    // strings that are now cleared.
+    clear_diffout(&dio.dio_diff);
+    for (int i = 0; i < DB_COUNT; i++)
+       ga_clear(&linemap[i]);
+}
+
+/*
+ * Find the difference within a changed line.
+ * Returns TRUE if the line was added, no other buffer has it.
+ */
+    int
+diff_find_change(
+    win_T      *wp,
+    linenr_T   lnum,
+    diffline_T *diffline)
+{
+    diff_T     *dp;
+    int                idx;
+    int                off;
+
+    idx = diff_buf_idx(wp->w_buffer);
+    if (idx == DB_COUNT)       // cannot happen
+       return FALSE;
+
+    // search for a change that includes "lnum" in the list of diffblocks.
+    FOR_ALL_DIFFBLOCKS_IN_TAB(curtab, dp)
+       if (lnum <= dp->df_lnum[idx] + dp->df_count[idx])
+           break;
+    if (dp->is_linematched)
+    {
+       while (dp && dp->df_next
+                       && lnum == dp->df_count[idx] + dp->df_lnum[idx]
+                       && dp->df_next->df_lnum[idx] == lnum)
+           dp = dp->df_next;
+    }
+    if (dp == NULL || diff_check_sanity(curtab, dp) == FAIL)
+       return FALSE;
+
+    if (lnum - dp->df_lnum[idx] > INT_MAX)
+       // Integer overflow protection
+       return FALSE;
+    off = lnum - dp->df_lnum[idx];
+
+    if (!(diff_flags & ALL_INLINE_DIFF) || diff_internal_failed())
+    {
+       // Use simple algorithm
+       int     change_start = MAXCOL;  // first col of changed area
+       int     change_end = -1;        // last col of changed area
+       int     ret;
+
+       ret = diff_find_change_simple(wp, lnum, dp, idx, &change_start, &change_end);
+
+       // convert from inclusive end to exclusive end per diffline's contract
+       change_end += 1;
+
+       // Create a mock diffline struct. We always only have one so no need to
+       // allocate memory.
+       idx = diff_buf_idx(wp->w_buffer);;
+       CLEAR_FIELD(simple_diffline_change);
+       diffline->changes = &simple_diffline_change;
+       diffline->num_changes = 1;
+       diffline->bufidx = idx;
+       diffline->lineoff = lnum - dp->df_lnum[idx];
+
+       simple_diffline_change.dc_start[idx] = change_start;
+       simple_diffline_change.dc_end[idx] = change_end;
+       simple_diffline_change.dc_start_lnum_off[idx] = off;
+       simple_diffline_change.dc_end_lnum_off[idx] = off;
+       return ret;
+    }
+
+    // Use inline diff algorithm.
+    // The diff changes are usually cached so we check that first.
+    if (!dp->has_changes)
+       diff_find_change_inline_diff(dp);
+
+    garray_T *changes = &dp->df_changes;
+
+    // Use linear search to find the first change for this line. We could
+    // optimize this to use binary search, but there should usually be a
+    // limited number of inline changes per diff block, and limited number of
+    // diff blocks shown on screen, so it is not necessary.
+    int num_changes = 0;
+    int change_idx = 0;
+    diffline->changes = NULL;
+    for (change_idx = 0; change_idx < changes->ga_len; change_idx++)
+    {
+       diffline_change_T *change = &((diffline_change_T*)dp->df_changes.ga_data)[change_idx];
+       if (change->dc_end_lnum_off[idx] < off)
+           continue;
+       if (change->dc_start_lnum_off[idx] > off)
+           break;
+       if (diffline->changes == NULL)
+           diffline->changes = change;
+       num_changes++;
+    }
+    diffline->num_changes = num_changes;
+    diffline->bufidx = idx;
+    diffline->lineoff = off;
+
+    // Detect simple cases of added lines in the end within a diff block. This
+    // has to be the last change of this diff block, and all other buffers are
+    // considering this to be an addition past their last line. Other scenarios
+    // will be considered a changed line instead.
+    int added = FALSE;
+    if (num_changes == 1 && change_idx == dp->df_changes.ga_len)
+    {
+       added = TRUE;
+       for (int i = 0; i < DB_COUNT; i++)
+       {
+           if (idx == i)
+               continue;
+           if (curtab->tp_diffbuf[i] == NULL)
+               continue;
+           diffline_change_T *change = &((diffline_change_T*)dp->df_changes.ga_data)[dp->df_changes.ga_len-1];
+           if (change->dc_start_lnum_off[i] != INT_MAX)
+           {
+               added = FALSE;
+               break;
+           }
+       }
+    }
+    return added;
+}
+
 #if defined(FEAT_FOLDING) || defined(PROTO)
 /*
  * Return TRUE if line "lnum" is not close to a diff block, this line should
@@ -3418,7 +4059,7 @@ ex_diffgetput(exarg_T *eap)
 #ifdef FEAT_FOLDING
                diff_fold_update(dfree, idx_to);
 #endif
-               vim_free(dfree);
+               clear_diffblock(dfree);
            }
 
            // mark_adjust() may have made "dp" invalid.  We don't know where
@@ -3881,23 +4522,38 @@ f_diff_hlID(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
     static linenr_T    prev_lnum = 0;
     static varnumber_T changedtick = 0;
     static int         fnum = 0;
+    static int         prev_diff_flags = 0;
     static int         change_start = 0;
     static int         change_end = 0;
     static hlf_T       hlID = (hlf_T)0;
+    int                        cache_results = TRUE;
     int                        filler_lines;
     int                        col;
+    diffline_T         diffline;
+
+    CLEAR_FIELD(diffline);
 
     if (in_vim9script()
            && (check_for_lnum_arg(argvars,0) == FAIL
                || check_for_number_arg(argvars, 1) == FAIL))
        return;
 
+    if (diff_flags & ALL_INLINE_DIFF)
+    {
+       // Remember the results if using simple since it's recalculated per
+       // call. Otherwise just call diff_find_change() every time since
+       // internally the result is cached interally.
+       cache_results = FALSE;
+    }
+
     lnum = tv_get_lnum(argvars);
     if (lnum < 0)      // ignore type error in {lnum} arg
        lnum = 0;
-    if (lnum != prev_lnum
+    if (!cache_results
+           || lnum != prev_lnum
            || changedtick != CHANGEDTICK(curbuf)
-           || fnum != curbuf->b_fnum)
+           || fnum != curbuf->b_fnum
+           || diff_flags != prev_diff_flags)
     {
        // New line, buffer, change: need to get the values.
        int linestatus = 0;
@@ -3908,28 +4564,60 @@ f_diff_hlID(typval_T *argvars UNUSED, typval_T *rettv UNUSED)
            {
                change_start = MAXCOL;
                change_end = -1;
-               if (diff_find_change(curwin, lnum, &change_start, &change_end))
+               if (diff_find_change(curwin, lnum, &diffline))
                    hlID = HLF_ADD;     // added line
                else
+               {
                    hlID = HLF_CHD;     // changed line
+                   if (diffline.num_changes > 0 && cache_results)
+                   {
+                       change_start = diffline.changes[0].dc_start[diffline.bufidx];
+                       change_end = diffline.changes[0].dc_end[diffline.bufidx];
+                   }
+               }
            }
            else
                hlID = HLF_ADD; // added line
        }
        else
            hlID = (hlf_T)0;
-       prev_lnum = lnum;
-       changedtick = CHANGEDTICK(curbuf);
-       fnum = curbuf->b_fnum;
+
+       if (cache_results)
+       {
+           prev_lnum = lnum;
+           changedtick = CHANGEDTICK(curbuf);
+           fnum = curbuf->b_fnum;
+           prev_diff_flags = diff_flags;
+       }
     }
 
     if (hlID == HLF_CHD || hlID == HLF_TXD)
     {
        col = tv_get_number(&argvars[1]) - 1; // ignore type error in {col}
-       if (col >= change_start && col <= change_end)
-           hlID = HLF_TXD;                     // changed text
+       if (cache_results)
+       {
+           if (col >= change_start && col < change_end)
+               hlID = HLF_TXD;                 // changed text
+           else
+               hlID = HLF_CHD;                 // changed line
+       }
        else
-           hlID = HLF_CHD;                     // changed line
+       {
+           hlID = HLF_CHD;
+           for (int i = 0; i < diffline.num_changes; i++)
+           {
+               int added = diff_change_parse(&diffline, &diffline.changes[i],
+                       &change_start, &change_end);
+               if (col >= change_start && col < change_end)
+               {
+                   hlID = added ? HLF_TXA : HLF_TXD;
+                   break;
+               }
+               if (col < change_start)
+                   // the remaining changes are past this column and not relevant
+                   break;
+           }
+       }
     }
     rettv->vval.v_number = hlID == (hlf_T)0 ? 0 : (int)hlID;
 # endif
@@ -4008,7 +4696,7 @@ list_to_diffin(list_T *l, diffin_T *din, int icase)
     listitem_T *li;
     char_u     *str;
 
-    ga_init2(&ga, 512, 4);
+    ga_init2(&ga, 1, 2048);
 
     FOR_ALL_LIST_ITEMS(l, li)
     {
@@ -4020,12 +4708,10 @@ list_to_diffin(list_T *l, diffin_T *din, int icase)
                continue;
        }
        ga_concat(&ga, str);
-       ga_concat(&ga, (char_u *)NL_STR);
+       ga_append(&ga, NL);
        if (icase)
            vim_free(str);
     }
-    if (ga.ga_len > 0)
-       ((char *)ga.ga_data)[ga.ga_len] = NUL;
 
     din->din_mmfile.ptr = (char *)ga.ga_data;
     din->din_mmfile.size = ga.ga_len;

diff --git a/src/drawline.c b/src/drawline.c
index 764d0fbaa50e7050051420729c3edeb91c04dea0..a14dd906225fbd6dd2f3586c2a909df6cc34c4c0 100644 (file)
--- a/src/drawline.c
+++ b/src/drawline.c
@@ -1223,6 +1223,8 @@ win_line(
 #ifdef FEAT_DIFF
     int                change_start = MAXCOL;  // first col of changed area
     int                change_end = -1;        // last col of changed area
+    diffline_T line_changes;
+    int                change_index = -1;
 #endif
     colnr_T    trailcol = MAXCOL;      // start of trailing spaces
     colnr_T    leadcol = 0;            // start of leading spaces
@@ -1471,16 +1473,37 @@ win_line(
     int linestatus = 0;
     wlv.filler_lines = diff_check_with_linestatus(wp, lnum, &linestatus);
 
+    CLEAR_FIELD(line_changes);
+
     if (wlv.filler_lines < 0 || linestatus < 0)
     {
        if (wlv.filler_lines == -1 || linestatus == -1)
        {
-           if (diff_find_change(wp, lnum, &change_start, &change_end))
+           if (diff_find_change(wp, lnum, &line_changes))
+           {
                wlv.diff_hlf = HLF_ADD; // added line
-           else if (change_start == 0)
-               wlv.diff_hlf = HLF_TXD; // changed text
+           }
+           else if (line_changes.num_changes > 0)
+           {
+               int added = diff_change_parse(
+                       &line_changes, &line_changes.changes[0],
+                       &change_start, &change_end);
+               if (change_start == 0)
+               {
+                   if (added)
+                       wlv.diff_hlf = HLF_TXA; // added text on changed line
+                   else
+                       wlv.diff_hlf = HLF_TXD; // changed text on changed line
+               }
+               else
+                   wlv.diff_hlf = HLF_CHD;     // unchanged text on changed line
+               change_index = 0;
+           }
            else
+           {
                wlv.diff_hlf = HLF_CHD; // changed line
+               change_index = 0;
+           }
        }
        else
            wlv.diff_hlf = HLF_ADD;
@@ -2438,13 +2461,28 @@ win_line(
 #ifdef FEAT_DIFF
            if (wlv.diff_hlf != (hlf_T)0)
            {
+               if (line_changes.num_changes > 0
+                       && change_index >= 0
+                       && change_index < line_changes.num_changes - 1)
+               {
+                   if (ptr - line >= line_changes.changes[change_index+1].dc_start[line_changes.bufidx])
+                       change_index += 1;
+               }
+               int added = FALSE;
+               if (line_changes.num_changes > 0 && change_index >= 0 && change_index < line_changes.num_changes)
+               {
+                   added = diff_change_parse(&line_changes,
+                           &line_changes.changes[change_index],
+                           &change_start,
+                           &change_end);
+               }
                // When there is extra text (e.g. virtual text) it gets the
                // diff highlighting for the line, but not for changed text.
                if (wlv.diff_hlf == HLF_CHD && ptr - line >= change_start
                                                           && wlv.n_extra == 0)
-                   wlv.diff_hlf = HLF_TXD;             // changed text
-               if (wlv.diff_hlf == HLF_TXD
-                       && ((ptr - line > change_end && wlv.n_extra == 0)
+                   wlv.diff_hlf = added ? HLF_TXA : HLF_TXD;   // added/changed text
+               if ((wlv.diff_hlf == HLF_TXD || wlv.diff_hlf == HLF_TXA)
+                       && ((ptr - line >= change_end && wlv.n_extra == 0)
                               || (wlv.n_extra > 0 && wlv.extra_for_textprop)))
                    wlv.diff_hlf = HLF_CHD;             // changed line
                wlv.line_attr = HL_ATTR(wlv.diff_hlf);
@@ -3502,7 +3540,7 @@ win_line(
                        wlv.char_attr = wlv.sattr.sat_linehl;
 #endif
 # ifdef FEAT_DIFF
-                   if (wlv.diff_hlf == HLF_TXD)
+                   if (wlv.diff_hlf == HLF_TXD || wlv.diff_hlf == HLF_TXA)
                    {
                        wlv.diff_hlf = HLF_CHD;
                        if (vi_attr == 0 || wlv.char_attr != vi_attr)

diff --git a/src/highlight.c b/src/highlight.c
index 755d75f4ca72d862f8771c554c6e49e5f3c2eb65..65670350bd07ceb70f4578305a231714810d6394 100644 (file)
--- a/src/highlight.c
+++ b/src/highlight.c
@@ -241,6 +241,7 @@ static char *(highlight_init_both[]) = {
 #ifdef FEAT_DIFF
     CENT("DiffText term=reverse cterm=bold ctermbg=Red",
         "DiffText term=reverse cterm=bold ctermbg=Red gui=bold guibg=Red"),
+    "default link DiffTextAdd DiffText",
 #endif
     CENT("PmenuSbar ctermbg=Grey",
         "PmenuSbar ctermbg=Grey guibg=Grey"),

diff --git a/src/optiondefs.h b/src/optiondefs.h
index 38e871c88965dd90c48a913830f1c322eabcbe49..3621635c1073c36d0097dac79e4fa134043d9458 100644 (file)
--- a/src/optiondefs.h
+++ b/src/optiondefs.h
@@ -303,7 +303,7 @@ struct vimoption
 # define ISP_LATIN1 (char_u *)"@,161-255"
 #endif
 
-# define HIGHLIGHT_INIT "8:SpecialKey,~:EndOfBuffer,@:NonText,d:Directory,e:ErrorMsg,i:IncSearch,l:Search,y:CurSearch,m:MoreMsg,M:ModeMsg,n:LineNr,a:LineNrAbove,b:LineNrBelow,N:CursorLineNr,G:CursorLineSign,O:CursorLineFold,r:Question,s:StatusLine,S:StatusLineNC,c:VertSplit,t:Title,v:Visual,V:VisualNOS,w:WarningMsg,W:WildMenu,f:Folded,F:FoldColumn,A:DiffAdd,C:DiffChange,D:DiffDelete,T:DiffText,>:SignColumn,-:Conceal,B:SpellBad,P:SpellCap,R:SpellRare,L:SpellLocal,+:Pmenu,=:PmenuSel,k:PmenuMatch,<:PmenuMatchSel,[:PmenuKind,]:PmenuKindSel,{:PmenuExtra,}:PmenuExtraSel,x:PmenuSbar,X:PmenuThumb,*:TabLine,#:TabLineSel,_:TabLineFill,!:CursorColumn,.:CursorLine,o:ColorColumn,q:QuickFixLine,z:StatusLineTerm,Z:StatusLineTermNC,g:MsgArea,h:ComplMatchIns"
+# define HIGHLIGHT_INIT "8:SpecialKey,~:EndOfBuffer,@:NonText,d:Directory,e:ErrorMsg,i:IncSearch,l:Search,y:CurSearch,m:MoreMsg,M:ModeMsg,n:LineNr,a:LineNrAbove,b:LineNrBelow,N:CursorLineNr,G:CursorLineSign,O:CursorLineFold,r:Question,s:StatusLine,S:StatusLineNC,c:VertSplit,t:Title,v:Visual,V:VisualNOS,w:WarningMsg,W:WildMenu,f:Folded,F:FoldColumn,A:DiffAdd,C:DiffChange,D:DiffDelete,T:DiffText,E:DiffTextAdd,>:SignColumn,-:Conceal,B:SpellBad,P:SpellCap,R:SpellRare,L:SpellLocal,+:Pmenu,=:PmenuSel,k:PmenuMatch,<:PmenuMatchSel,[:PmenuKind,]:PmenuKindSel,{:PmenuExtra,}:PmenuExtraSel,x:PmenuSbar,X:PmenuThumb,*:TabLine,#:TabLineSel,_:TabLineFill,!:CursorColumn,.:CursorLine,o:ColorColumn,q:QuickFixLine,z:StatusLineTerm,Z:StatusLineTermNC,g:MsgArea,h:ComplMatchIns"
 
 // Default python version for pyx* commands
 #if defined(FEAT_PYTHON) && defined(FEAT_PYTHON3)
@@ -845,7 +845,7 @@ static struct vimoption options[] =
                                                                     |P_NODUP,
 #ifdef FEAT_DIFF
                            (char_u *)&p_dip, PV_NONE, did_set_diffopt, expand_set_diffopt,
-                           {(char_u *)"internal,filler,closeoff",
+                           {(char_u *)"internal,filler,closeoff,inline:simple",
                                                                (char_u *)NULL}
 #else
                            (char_u *)NULL, PV_NONE, NULL, NULL,

diff --git a/src/optionstr.c b/src/optionstr.c
index 517a8358c0d942db0e461afec1e8127a02fc6a8b..60e28d68b77eb9666578cd9e8f77d995d4710b16 100644 (file)
--- a/src/optionstr.c
+++ b/src/optionstr.c
@@ -30,8 +30,9 @@ static char *(p_briopt_values[]) = {"shift:", "min:", "sbr", "list:", "column:",
 #endif
 #if defined(FEAT_DIFF)
 // Note: Keep this in sync with diffopt_changed()
-static char *(p_dip_values[]) = {"filler", "context:", "iblank", "icase", "iwhite", "iwhiteall", "iwhiteeol", "horizontal", "vertical", "closeoff", "hiddenoff", "foldcolumn:", "followwrap", "internal", "indent-heuristic", "algorithm:", "linematch:", NULL};
+static char *(p_dip_values[]) = {"filler", "context:", "iblank", "icase", "iwhite", "iwhiteall", "iwhiteeol", "horizontal", "vertical", "closeoff", "hiddenoff", "foldcolumn:", "followwrap", "internal", "indent-heuristic", "algorithm:", "inline:", "linematch:", NULL};
 static char *(p_dip_algorithm_values[]) = {"myers", "minimal", "patience", "histogram", NULL};
+static char *(p_dip_inline_values[]) = {"none", "simple", "char", "word", NULL};
 #endif
 static char *(p_nf_values[]) = {"bin", "octal", "hex", "alpha", "unsigned", "blank", NULL};
 static char *(p_ff_values[]) = {FF_UNIX, FF_DOS, FF_MAC, NULL};
@@ -2017,6 +2018,18 @@ expand_set_diffopt(optexpand_T *args, int *numMatches, char_u ***matches)
                    numMatches,
                    matches);
        }
+       // Within "inline:", we have a subgroup of possible options.
+       int inline_len = (int)STRLEN("inline:");
+       if (xp->xp_pattern - args->oe_set_arg >= inline_len &&
+               STRNCMP(xp->xp_pattern - inline_len, "inline:", inline_len) == 0)
+       {
+           return expand_set_opt_string(
+                   args,
+                   p_dip_inline_values,
+                   ARRAY_LENGTH(p_dip_inline_values) - 1,
+                   numMatches,
+                   matches);
+       }
        return FAIL;
     }
 

diff --git a/src/proto/diff.pro b/src/proto/diff.pro
index 93272ac660690e7f1f6d40f7b7b9b57f2c00adf1..d4482b13e26dafd85a91ae23b26e952b707f3f23 100644 (file)
--- a/src/proto/diff.pro
+++ b/src/proto/diff.pro
@@ -21,7 +21,11 @@ int diffopt_changed(void);
 int diffopt_horizontal(void);
 int diffopt_hiddenoff(void);
 int diffopt_closeoff(void);
-int diff_find_change(win_T *wp, linenr_T lnum, int *startp, int *endp);
+void diff_update_line(linenr_T lnum);
+#ifdef FEAT_DIFF
+int diff_change_parse( diffline_T *diffline, diffline_change_T *change, int *change_start, int *change_end);
+int diff_find_change( win_T *wp, linenr_T lnum, diffline_T *diffline);
+#endif
 int diff_infold(win_T *wp, linenr_T lnum);
 void nv_diffgetput(int put, long count);
 void ex_diffgetput(exarg_T *eap);

diff --git a/src/structs.h b/src/structs.h
index 1a3abcb72a60494df4219dfaf0471948765b65ed..33c26dc6bfa8b64aa6c07dbde93cd0fbaf7e7b84 100644 (file)
--- a/src/structs.h
+++ b/src/structs.h
@@ -3571,14 +3571,17 @@ struct file_buffer
  * and how many lines it occupies in that buffer.  When the lines are missing
  * in the buffer the df_count[] is zero.  This is all counted in
  * buffer lines.
- * There is always at least one unchanged line in between the diffs.
- * Otherwise it would have been included in the diff above or below it.
+ * There is always at least one unchanged line in between the diffs (unless
+ * linematch is used).  Otherwise it would have been included in the diff above
+ * or below it.
  * df_lnum[] + df_count[] is the lnum below the change.  When in one buffer
  * lines have been inserted, in the other buffer df_lnum[] is the line below
  * the insertion and df_count[] is zero.  When appending lines at the end of
  * the buffer, df_lnum[] is one beyond the end!
  * This is using a linked list, because the number of differences is expected
  * to be reasonable small.  The list is sorted on lnum.
+ * Each diffblock also contains a cached list of inline diff of changes within
+ * the block, used for highlighting.
  */
 typedef struct diffblock_S diff_T;
 struct diffblock_S
@@ -3588,6 +3591,37 @@ struct diffblock_S
     linenr_T   df_count[DB_COUNT];     // nr of inserted/changed lines
     int is_linematched;  // has the linematch algorithm ran on this diff hunk to divide it into
                          // smaller diff hunks?
+
+    int                has_changes;            // has cached list of inline changes
+    garray_T   df_changes;             // list of inline changes (diffline_change_T)
+};
+
+/*
+ * Each entry stores a single inline change within a diff block. Line numbers
+ * are recorded as relative offsets, and columns are byte offsets, not
+ * character counts.
+ * Ranges are [start,end), with the end being exclusive.
+ */
+typedef struct diffline_change_S diffline_change_T;
+struct diffline_change_S
+{
+    colnr_T    dc_start[DB_COUNT];     // byte offset of start of range in the line
+    colnr_T    dc_end[DB_COUNT];       // 1 paste byte offset of end of range in line
+    int                dc_start_lnum_off[DB_COUNT];    // starting line offset
+    int                dc_end_lnum_off[DB_COUNT];      // end line offset
+};
+
+/*
+ * Describes a single line's list of inline changes. Use diff_change_parse() to
+ * parse this.
+ */
+typedef struct diffline_S diffline_T;
+struct diffline_S
+{
+    diffline_change_T *changes;
+    int num_changes;
+    int bufidx;
+    int lineoff;
 };
 #endif
 

diff --git a/src/testdir/dumps/Test_diff_inline_01.dump b/src/testdir/dumps/Test_diff_inline_01.dump
new file mode 100644 (file)
index 0000000..9f34257
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_01.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|b+2&#ff404010|c|d|e|f| |g|h|i| |j|k| +0&#ffd7ff255|n| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|B+2&#ff404010|c|e|f| |g|H|i| |l|m| +0&#ffd7ff255|n| @20
+| +0#0000e05#a8a8a8255@1|x+0#0000000#5fd7ff255| @33||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33
+| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|z+0#0000000#5fd7ff255| @33
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_02.dump b/src/testdir/dumps/Test_diff_inline_02.dump
new file mode 100644 (file)
index 0000000..2fb78a7
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_02.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|b|c|d|e|f| |g|h|i| |j|k| |n| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|B|c|e|f| |g|H|i| |l|m| |n| @20
+| +0#0000e05#a8a8a8255@1|x+0#0000000#5fd7ff255| @33||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33
+| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|z+0#0000000#5fd7ff255| @33
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_03.dump b/src/testdir/dumps/Test_diff_inline_03.dump
new file mode 100644 (file)
index 0000000..7e6cf2a
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_03.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|b+2&#ff404010|c+0&#ffd7ff255|d+2&#ff404010|e+0&#ffd7ff255|f| |g|h+2&#ff404010|i+0&#ffd7ff255| |j+2&#ff404010|k| +0&#ffd7ff255|n| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|B+2&#ff404010|c+0&#ffd7ff255|e|f| |g|H+2&#ff404010|i+0&#ffd7ff255| |l+2&#ff404010|m| +0&#ffd7ff255|n| @20
+| +0#0000e05#a8a8a8255@1|x+0#0000000#5fd7ff255| @33||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33
+| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|z+0#0000000#5fd7ff255| @33
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_04.dump b/src/testdir/dumps/Test_diff_inline_04.dump
new file mode 100644 (file)
index 0000000..ed4f5a2
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_04.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|a+2#0000000#ff404010|b|c|d|e|f| +0&#ffd7ff255|g+2&#ff404010|h|i| +0&#ffd7ff255|j+2&#ff404010|k| +0&#ffd7ff255|n| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|a+2#0000000#ff404010|B|c|e|f| +0&#ffd7ff255|g+2&#ff404010|H|i| +0&#ffd7ff255|l+2&#ff404010|m| +0&#ffd7ff255|n| @20
+| +0#0000e05#a8a8a8255@1|x+0#0000000#5fd7ff255| @33||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33
+| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|z+0#0000000#5fd7ff255| @33
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_05.dump b/src/testdir/dumps/Test_diff_inline_05.dump
new file mode 100644 (file)
index 0000000..f2d0c7c
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_05.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|b+2&#ff404010|c+0&#ffd7ff255|d+0&#4040ff13|e+0&#ffd7ff255|f| |g|h+2&#ff404010|i+0&#ffd7ff255| |j+2&#ff404010|k| +0&#ffd7ff255|n| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|B+2&#ff404010|c+0&#ffd7ff255|e|f| |g|H+2&#ff404010|i+0&#ffd7ff255| |l+2&#ff404010|m| +0&#ffd7ff255|n| @20
+| +0#0000e05#a8a8a8255@1|x+0#0000000#5fd7ff255| @33||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33
+| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|z+0#0000000#5fd7ff255| @33
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_06.dump b/src/testdir/dumps/Test_diff_inline_06.dump
new file mode 100644 (file)
index 0000000..67f4b5b
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_06.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|s+2#0000000#ff404010|o|m|e|t|e|x|t>a|b|c|d|e+0&#ffd7ff255|f| |g|h+2&#ff404010|i+0&#ffd7ff255| |j+2&#ff404010|k| +0&#ffd7ff255|n| @11||+1&#ffffff0| +0#0000e05#a8a8a8255@1|a+2#0000000#ff404010|B|c|e+0&#ffd7ff255|f| |g|H+2&#ff404010|i+0&#ffd7ff255| |l+2&#ff404010|m| +0&#ffd7ff255|n| @20
+| +0#0000e05#a8a8a8255@1|x+0#0000000#5fd7ff255| @33||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33
+| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|z+0#0000000#5fd7ff255| @33
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| |[|+|]| @6|1|,|9| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|9| @11|A|l@1
+|-+2&&@1| |I|N|S|E|R|T| |-@1| +0&&@62

diff --git a/src/testdir/dumps/Test_diff_inline_07.dump b/src/testdir/dumps/Test_diff_inline_07.dump
new file mode 100644 (file)
index 0000000..3129968
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_07.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|b|c|d+2&#ff404010|e|f| |g|h|i| |j|k| +0&#ffd7ff255|n| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|B|c|e+2&#ff404010|f| |g|H|i| |l|m| +0&#ffd7ff255|n| @20
+| +0#0000e05#a8a8a8255@1|x+0#0000000#5fd7ff255| @33||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33
+| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|z+0#0000000#5fd7ff255| @33
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_08.dump b/src/testdir/dumps/Test_diff_inline_08.dump
new file mode 100644 (file)
index 0000000..baf74b5
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_08.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|b|c|d+0&#4040ff13|e+0&#ffd7ff255|f| |g|h|i| |j+2&#ff404010|k| +0&#ffd7ff255|n| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|B|c|e|f| |g|H|i| |l+2&#ff404010|m| +0&#ffd7ff255|n| @20
+| +0#0000e05#a8a8a8255@1|x+0#0000000#5fd7ff255| @33||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33
+| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|z+0#0000000#5fd7ff255| @33
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_09.dump b/src/testdir/dumps/Test_diff_inline_09.dump
new file mode 100644 (file)
index 0000000..b8dcad6
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_09.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|a+2#0000000#ff404010|b|c|d|e|f| +0&#ffd7ff255|g|h|i| |j+2&#ff404010|k| +0&#ffd7ff255|n| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|a+2#0000000#ff404010|B|c|e|f| +0&#ffd7ff255|g|H|i| |l+2&#ff404010|m| +0&#ffd7ff255|n| @20
+| +0#0000e05#a8a8a8255@1|x+0#0000000#5fd7ff255| @33||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33||+1&&| +0#0000e05#a8a8a8255@1|y+0#0000000#ffffff0| @33
+| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|z+0#0000000#5fd7ff255| @33
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_10.dump b/src/testdir/dumps/Test_diff_inline_10.dump
new file mode 100644 (file)
index 0000000..27095fb
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_10.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|a+2#0000000#ff404010|p@1|l|e+0&#ffd7ff255|s| |a|n|d| |o+2&#ff404010|r|a|n|g|e+0&#ffd7ff255|s| @16||+1&#ffffff0| +0#0000e05#a8a8a8255@1|o+2#0000000#ff404010|r|a|n|g|e+0&#ffd7ff255|s| |a|n|d| |a+2&#ff404010|p@1|l|e+0&#ffd7ff255|s| @16
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_11.dump b/src/testdir/dumps/Test_diff_inline_11.dump
new file mode 100644 (file)
index 0000000..a485a9a
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_11.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|a+0#0000000#4040ff13|p@1|l|e|s| |a|n|d| |o+0&#ffd7ff255|r|a|n|g|e|s| @16||+1&#ffffff0| +0#0000e05#a8a8a8255@1|o+0#0000000#ffd7ff255|r|a|n|g|e|s| +0&#4040ff13|a|n|d| |a|p@1|l|e|s| +0&#ffd7ff255@16
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_12.dump b/src/testdir/dumps/Test_diff_inline_12.dump
new file mode 100644 (file)
index 0000000..b6894f3
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_12.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|1+2#0000000#ff404010| +0&#ffd7ff255|-| |s+2&#ff404010|i+0&#ffd7ff255|g|m|a| |i|n| |6|σ+2&#ff404010| +0&#ffd7ff255|a|n|d| |Ὀ|δ+2&#ff404010|υ|σ@1|ε|ύ|ς| +0&#ffd7ff255@6||+1&#ffffff0| +0#0000e05#a8a8a8255@1|2+2#0000000#ff404010| +0&#ffd7ff255|-| |S+2&#ff404010|i+0&#ffd7ff255|g|m|a| |i|n| |6|Σ+2&#ff404010| +0&#ffd7ff255|a|n|d| |Ὀ|Δ+2&#ff404010|Υ|Σ@1|Ε|Ύ|Σ| +0&#ffd7ff255@6
+| +0#0000e05#a8a8a8255@1|1+2#0000000#ff404010| +0&#ffd7ff255|-| |a+2&#ff404010|n+0&#ffd7ff255|g|s|t|r|o|m| |i|n| |å+2&#ff404010@1| +0&#ffd7ff255@16||+1&#ffffff0| +0#0000e05#a8a8a8255@1|2+2#0000000#ff404010| +0&#ffd7ff255|-| |A+2&#ff404010|n+0&#ffd7ff255|g|s|t|r|o|m| |i|n| |Å+2&#ff404010|Å| +0&#ffd7ff255@16
+| +0#0000e05#a8a8a8255@1|1+2#0000000#ff404010| +0&#ffd7ff255|-| |c+2&#ff404010|o+0&#ffd7ff255|m|p|o|s|i|n|g|:| |i+0&#4040ff13|i⃗+0&#ffd7ff255|I⃗| @16||+1&#ffffff0| +0#0000e05#a8a8a8255@1|2+2#0000000#ff404010| +0&#ffd7ff255|-| |C+2&#ff404010|o+0&#ffd7ff255|m|p|o|s|i|n|g|:| |i⃗|I⃗|I⃗+0&#4040ff13| +0&#ffd7ff255@16
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_13.dump b/src/testdir/dumps/Test_diff_inline_13.dump
new file mode 100644 (file)
index 0000000..a3ddf8c
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_13.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|1+2#0000000#ff404010| +0&#ffd7ff255|-| |s|i|g|m|a| |i|n| |6|σ| |a|n|d| |Ὀ|δ|υ|σ@1|ε|ύ|ς| @6||+1&#ffffff0| +0#0000e05#a8a8a8255@1|2+2#0000000#ff404010| +0&#ffd7ff255|-| |S|i|g|m|a| |i|n| |6|Σ| |a|n|d| |Ὀ|Δ|Υ|Σ@1|Ε|Ύ|Σ| @6
+| +0#0000e05#a8a8a8255@1|1+2#0000000#ff404010| +0&#ffd7ff255|-| |a|n|g|s|t|r|o|m| |i|n| |å@1| @16||+1&#ffffff0| +0#0000e05#a8a8a8255@1|2+2#0000000#ff404010| +0&#ffd7ff255|-| |A|n|g|s|t|r|o|m| |i|n| |Å|Å| @16
+| +0#0000e05#a8a8a8255@1|1+2#0000000#ff404010| +0&#ffd7ff255|-| |c|o|m|p|o|s|i|n|g|:| |i+2&#ff404010|i⃗+0&#ffd7ff255|I⃗| @16||+1&#ffffff0| +0#0000e05#a8a8a8255@1|2+2#0000000#ff404010| +0&#ffd7ff255|-| |C|o|m|p|o|s|i|n|g|:| |i⃗+2&#ff404010|I⃗+0&#ffd7ff255@1| @16
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_14.dump b/src/testdir/dumps/Test_diff_inline_14.dump
new file mode 100644 (file)
index 0000000..9946527
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_14.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|b|c|😅*2&#ff404010|x+&|d+0&#ffd7ff255|e|一*0&#4040ff13| +0&#ffd7ff255@24||+1&#ffffff0| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|b|c|y+2&#ff404010|😢*&|d+0&#ffd7ff255|e| @26
+| +0#0000e05#a8a8a8255@1|f+0#0000000#ffd7ff255|🚀*&|g+&| @30||+1&#ffffff0| +0#0000e05#a8a8a8255@1|二*0#0000000#4040ff13|f+0&#ffd7ff255|🚀*&|g+&| @28
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_15.dump b/src/testdir/dumps/Test_diff_inline_15.dump
new file mode 100644 (file)
index 0000000..91ac04b
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_15.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|1+0#0000000#ffd7ff255|^+2#0000e05#ff404010|@|3+0#0000000#ffd7ff255|4|^+0#0000e05&|@|5+0#0000000&|^+2#0000e05#ff404010|@|6+0#0000000#ffd7ff255| @23||+1&#ffffff0| +0#0000e05#a8a8a8255@1|1+0#0000000#ffd7ff255|2+2&#ff404010|3+0&#ffd7ff255|4|^+0#0000e05&|@|5+0#0000000&| @27
+| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|6+0#0000000#ffd7ff255| @33
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_char_01.dump b/src/testdir/dumps/Test_diff_inline_char_01.dump
new file mode 100644 (file)
index 0000000..ce703ea
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_char_01.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|p+0#0000000#ffd7ff255|r|e|f|i|x|F|o@1|,| |p|r|e|f|i|x|E|n|d| @14||+1&#ffffff0| +0#0000e05#a8a8a8255@1|p+0#0000000#ffd7ff255|r|e|f|i|x|F|o@1|,| |p+0&#4040ff13|r|e|f|i|x|B|a|r|,| |p+0&#ffd7ff255|r|e|f|i|x|E|n|d| @3
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_char_02.dump b/src/testdir/dumps/Test_diff_inline_char_02.dump
new file mode 100644 (file)
index 0000000..b707200
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_char_02.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|b+2&#ff404010|c+0&#ffd7ff255|d+2&#ff404010|e|f|g|h|i|j|k|l|m|n|o+0&#ffd7ff255| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|?+2&#ff404010|c+0&#ffd7ff255|?+2&#ff404010|e|?|g|?|i|?|k|?@2|o+0&#ffd7ff255| @19
+| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r|1| @27||+1&&| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r|1| @27
+| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|b+2&#ff404010|c|d+0&#ffd7ff255|e|f+2&#ff404010|g|h|i|j|k+0&#ffd7ff255|l|m|n|o| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|?+2&#ff404010@1|d+0&#ffd7ff255|e|?+2&#ff404010@4|k+0&#ffd7ff255|l|m|n|o| @19
+| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r|2| @27||+1&&| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r|2| @27
+| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|b+2&#ff404010|c|d|e|f|g|h|i|j|k|l+0&#ffd7ff255|m|n|o| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|?+2&#ff404010@1|d|e|?@5|l+0&#ffd7ff255|m|n|o| @19
+| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r|3| @27||+1&&| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r|3| @27
+| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|e+2&#ff404010|s+0&#ffd7ff255|t+2&#ff404010| +0&#ffd7ff255@30||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|?+2&#ff404010|s+0&#ffd7ff255|?+2&#ff404010| +0&#ffd7ff255@30
+| +0#0000e05#a8a8a8255@1|m+2#0000000#ff404010|u|l|t|i|l|i|n|e+0&#ffd7ff255| @25||+1&#ffffff0| +0#0000e05#a8a8a8255@1|?+2#0000000#ff404010@5|i|?|e+0&#ffd7ff255| @25
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_multibuffer_01.dump b/src/testdir/dumps/Test_diff_inline_multibuffer_01.dump
new file mode 100644 (file)
index 0000000..8b40257
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multibuffer_01.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|T+0#0000000#ffd7ff255|h|a+2&#ff404010|t| +0&#ffd7ff255|i|s| |b|u|f@1|e|r|1+2&#ff404010|.+0&#ffd7ff255| @6||+1&#ffffff0| +0#0000e05#a8a8a8255@1|T+0#0000000#ffd7ff255|h|i+2&#ff404010|s| +0&#ffd7ff255|i|s| |b|u|f@1|e|r|2+2&#ff404010|.+0&#ffd7ff255| @5||+1&#ffffff0| +0#0000e05#a8a8a8255@1|T+0#0000000#ffd7ff255|h|i+2&#ff404010|s| +0&#ffd7ff255|i|s| |b|u|f@1|e|r|3+2&#ff404010|.| |L|a|s|t|.+0&#ffd7ff255
+| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r| @16||+1&&| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r| @15||+1&&| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r| @15
+| +0#0000e05#a8a8a8255@1|S+0#0000000#ffd7ff255|o|m|e| |r+2&#ff404010|a|n|d|o|m| |t+0&#ffd7ff255|e|x|t| @6||+1&#ffffff0| +0#0000e05#a8a8a8255@1|S+0#0000000#ffd7ff255|o|m|e| |t|e|x|t| @12||+1&#ffffff0| +0#0000e05#a8a8a8255@1|S+0#0000000#ffd7ff255|o|m|e| |m+2&#ff404010|o|r|e| +0&#ffd7ff255@12
+| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@22||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@21||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|e|x|t| +0&#4040ff13|h|e|r|e|.| +0&#ffd7ff255@11
+| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r| @16||+1&&| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r| @15||+1&&| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r| @15
+| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@22||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|b+0#0000000#ffd7ff255|u|f@1|e|r|2|/|3| @12||+1&#ffffff0| +0#0000e05#a8a8a8255@1|o+0#0000000#4040ff13|n|l|y| |i|n| |b+0&#ffd7ff255|u|f@1|e|r|2|/|3| @4
+| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@22||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@21||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|n+0#0000000#5fd7ff255|o|t| |i|n| |b|u|f@1|e|r|1| @7
+|~+0#4040ff13#ffffff0| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|X+3#0000000&|d|i|f|i|l|e|1| @4|1|,|1| @5|A|l@1| |X+1&&|d|i|f|i|l|e|2| @3|1|,|1| @5|A|l@1| |X|d|i|f|i|l|e|3| @3|1|,|1| @5|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_multibuffer_02.dump b/src/testdir/dumps/Test_diff_inline_multibuffer_02.dump
new file mode 100644 (file)
index 0000000..d6358d4
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multibuffer_02.dump
@@ -0,0 +1,20 @@
+|T+0&#ffffff0|h|a|t| |i|s| |b|u|f@1|e|r|1|.| @8||+1&&| +0#0000e05#a8a8a8255@1|T+0#0000000#ffd7ff255|h|i|s| |i|s| |b|u|f@1|e|r|2+2&#ff404010|.+0&#ffd7ff255| @5||+1&#ffffff0| +0#0000e05#a8a8a8255@1|T+0#0000000#ffd7ff255|h|i|s| |i|s| |b|u|f@1|e|r|3+2&#ff404010|.| |L|a|s|t|.+0&#ffd7ff255
+|a+0&#ffffff0|n|c|h|o|r| @18||+1&&| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r| @15||+1&&| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r| @15
+|S|o|m|e| |r|a|n|d|o|m| |t|e|x|t| @8||+1&&| +0#0000e05#a8a8a8255@1|S+0#0000000#ffd7ff255|o|m|e| |t|e|x|t| @12||+1&#ffffff0| +0#0000e05#a8a8a8255@1|S+0#0000000#ffd7ff255|o|m|e| |m+0&#4040ff13|o|r|e| +0&#ffd7ff255@12
+|a+0&#ffffff0|n|c|h|o|r| @18||+1&&| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@21||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|e|x|t| +0&#4040ff13|h|e|r|e|.| +0&#ffd7ff255@11
+|~+0#4040ff13#ffffff0| @23||+1#0000000&| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r| @15||+1&&| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r| @15
+|~+0#4040ff13&| @23||+1#0000000&| +0#0000e05#a8a8a8255@1|b+0#0000000#ffd7ff255|u|f@1|e|r|2|/|3| @12||+1&#ffffff0| +0#0000e05#a8a8a8255@1|o+0#0000000#4040ff13|n|l|y| |i|n| |b+0&#ffd7ff255|u|f@1|e|r|2|/|3| @4
+|~+0#4040ff13#ffffff0| @23||+1#0000000&| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@21||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|n+0#0000000#5fd7ff255|o|t| |i|n| |b|u|f@1|e|r|1| @7
+|~+0#4040ff13#ffffff0| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|X+3#0000000&|d|i|f|i|l|e|1| @4|1|,|1| @5|A|l@1| |X+1&&|d|i|f|i|l|e|2| @3|1|,|1| @5|A|l@1| |X|d|i|f|i|l|e|3| @3|1|,|1| @5|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_multibuffer_03.dump b/src/testdir/dumps/Test_diff_inline_multibuffer_03.dump
new file mode 100644 (file)
index 0000000..21bbfba
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multibuffer_03.dump
@@ -0,0 +1,20 @@
+|s+0&#ffffff0|o|m|e|t|e|x|t>T|h|a|t| |i|s| |b|u|f@1|e|r|1|.| ||+1&&| +0#0000e05#a8a8a8255@1|T+0#0000000#ffd7ff255|h|i|s| |i|s| |b|u|f@1|e|r|2+2&#ff404010|.+0&#ffd7ff255| @5||+1&#ffffff0| +0#0000e05#a8a8a8255@1|T+0#0000000#ffd7ff255|h|i|s| |i|s| |b|u|f@1|e|r|3+2&#ff404010|.| |L|a|s|t|.+0&#ffd7ff255
+|a+0&#ffffff0|n|c|h|o|r| @18||+1&&| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r| @15||+1&&| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r| @15
+|S|o|m|e| |r|a|n|d|o|m| |t|e|x|t| @8||+1&&| +0#0000e05#a8a8a8255@1|S+0#0000000#ffd7ff255|o|m|e| |t|e|x|t| @12||+1&#ffffff0| +0#0000e05#a8a8a8255@1|S+0#0000000#ffd7ff255|o|m|e| |m+0&#4040ff13|o|r|e| +0&#ffd7ff255@12
+|a+0&#ffffff0|n|c|h|o|r| @18||+1&&| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@21||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|e|x|t| +0&#4040ff13|h|e|r|e|.| +0&#ffd7ff255@11
+|~+0#4040ff13#ffffff0| @23||+1#0000000&| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r| @15||+1&&| +0#0000e05#a8a8a8255@1|a+0#0000000#ffffff0|n|c|h|o|r| @15
+|~+0#4040ff13&| @23||+1#0000000&| +0#0000e05#a8a8a8255@1|b+0#0000000#ffd7ff255|u|f@1|e|r|2|/|3| @12||+1&#ffffff0| +0#0000e05#a8a8a8255@1|o+0#0000000#4040ff13|n|l|y| |i|n| |b+0&#ffd7ff255|u|f@1|e|r|2|/|3| @4
+|~+0#4040ff13#ffffff0| @23||+1#0000000&| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@21||+1#0000000#ffffff0| +0#0000e05#a8a8a8255@1|n+0#0000000#5fd7ff255|o|t| |i|n| |b|u|f@1|e|r|1| @7
+|~+0#4040ff13#ffffff0| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|<+3#0000000&|d|i|f|i|l|e|1| |[|+|]| |1|,|9| @5|A|l@1| |X+1&&|d|i|f|i|l|e|2| @3|1|,|1| @5|A|l@1| |X|d|i|f|i|l|e|3| @3|1|,|1| @5|A|l@1
+|-+2&&@1| |I|N|S|E|R|T| |-@1| +0&&@62

diff --git a/src/testdir/dumps/Test_diff_inline_multibuffer_04.dump b/src/testdir/dumps/Test_diff_inline_multibuffer_04.dump
new file mode 100644 (file)
index 0000000..3da504b
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multibuffer_04.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|T+2#0000000#ff404010|h|i|s|+|i|s|=+0&#ffd7ff255|a+2&#ff404010|-+0&#ffd7ff255|s|e|t|e|n|c|e| @5||+1&#ffffff0| +0#0000e05#a8a8a8255@1|T+2#0000000#ff404010|h|i|s|+|i|s|=+0&#ffd7ff255|a+2&#ff404010|n|o|t|h|e|r|-+0&#ffd7ff255|s|e|t|e|n|c||+1&#ffffff0| +0#0000e05#a8a8a8255@1|T+2#0000000#ff404010|h|a|t|+|i|s|=+0&#ffd7ff255|a+2&#ff404010|-+0&#ffd7ff255|s|e|t|e|n|c|e| @4
+|~+0#4040ff13#ffffff0| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|X+3#0000000&|d|i|f|i|l|e|1| @4|1|,|1| @5|A|l@1| |X+1&&|d|i|f|i|l|e|2| @3|1|,|1| @5|A|l@1| |X|d|i|f|i|l|e|3| @3|1|,|1| @5|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_multibuffer_05.dump b/src/testdir/dumps/Test_diff_inline_multibuffer_05.dump
new file mode 100644 (file)
index 0000000..0f5ef73
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multibuffer_05.dump
@@ -0,0 +1,20 @@
+|T+0&#ffffff0|h|i|s|+|i|s|=|a|-|s|e|t|e|n|c|e| @7||+1&&| +0#0000e05#a8a8a8255@1|T+2#0000000#ff404010|h|i|s|++0&#ffd7ff255|i|s|=|a+2&#ff404010|n|o|t|h|e|r|-|s|e|t|e|n|c||+1&#ffffff0| +0#0000e05#a8a8a8255@1|T+2#0000000#ff404010|h|a|t|++0&#ffd7ff255|i|s|=|a+2&#ff404010|-|s|e|t|e|n|c|e| +0&#ffd7ff255@4
+|~+0#4040ff13#ffffff0| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|X+3#0000000&|d|i|f|i|l|e|1| @4|1|,|1| @5|A|l@1| |X+1&&|d|i|f|i|l|e|2| @3|1|,|1| @5|A|l@1| |X|d|i|f|i|l|e|3| @3|1|,|1| @5|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_multibuffer_06.dump b/src/testdir/dumps/Test_diff_inline_multibuffer_06.dump
new file mode 100644 (file)
index 0000000..8c37b13
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multibuffer_06.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|b+2&#ff404010|c|d|e|f|g+0&#ffd7ff255|h|i|j|k|Y+2&#ff404010|m|Y@2| +0&#ffd7ff255@6||+1&#ffffff0| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|X+2&#ff404010@1|d|X@1|g+0&#ffd7ff255|h|i|j|k|l+2&#ff404010|m|n|o|p| +0&#ffd7ff255@5||+1&#ffffff0| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|b+2&#ff404010|c|d|e|f|g+0&#ffd7ff255|h|i|j|k|Y+2&#ff404010|m|Y|o|p| +0&#ffd7ff255@5
+|~+0#4040ff13#ffffff0| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|X+3#0000000&|d|i|f|i|l|e|1| @4|1|,|1| @5|A|l@1| |X+1&&|d|i|f|i|l|e|2| @3|1|,|1| @5|A|l@1| |X|d|i|f|i|l|e|3| @3|1|,|1| @5|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_multibuffer_07.dump b/src/testdir/dumps/Test_diff_inline_multibuffer_07.dump
new file mode 100644 (file)
index 0000000..0db4f77
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multibuffer_07.dump
@@ -0,0 +1,20 @@
+|a+0&#ffffff0|b|c|d|e|f|g|h|i|j|k|Y|m|Y@2| @8||+1&&| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|X+2&#ff404010@1|d|X@1|g+0&#ffd7ff255|h|i|j|k|l+2&#ff404010|m+0&#ffd7ff255|n+2&#ff404010|o+0&#ffd7ff255|p| @5||+1&#ffffff0| +0#0000e05#a8a8a8255@1|a+0#0000000#ffd7ff255|b+2&#ff404010|c|d|e|f|g+0&#ffd7ff255|h|i|j|k|Y+2&#ff404010|m+0&#ffd7ff255|Y+2&#ff404010|o+0&#ffd7ff255|p| @5
+|~+0#4040ff13#ffffff0| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|~| @23||+1#0000000&|~+0#4040ff13&| @22||+1#0000000&|~+0#4040ff13&| @22
+|X+3#0000000&|d|i|f|i|l|e|1| @4|1|,|1| @5|A|l@1| |X+1&&|d|i|f|i|l|e|2| @3|1|,|1| @5|A|l@1| |X|d|i|f|i|l|e|3| @3|1|,|1| @5|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_multiline_01.dump b/src/testdir/dumps/Test_diff_inline_multiline_01.dump
new file mode 100644 (file)
index 0000000..53d6139
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multiline_01.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| @2|i|s| @25||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| |i|s| |s|o|m|e| +0&#4040ff13|t+0&#ffd7ff255|e|s|t| @17
+| +0#0000e05#a8a8a8255@1|s+0#0000000#ffd7ff255|o|m|e|t|e|s|t| |t|e|x|t| |f|o@1| @17||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|e|x|t|s+0&#4040ff13| +0&#ffd7ff255@29
+| +0#0000e05#a8a8a8255@1|b+0#0000000#ffd7ff255|a|z+2&#ff404010| +0&#ffd7ff255|a|b|c+2&#ff404010| +0&#ffd7ff255|d+2&#ff404010|e+0&#ffd7ff255|f| @23||+1&#ffffff0| +0#0000e05#a8a8a8255@1|f+0#0000000#ffd7ff255|o@1| |b|a|r+2&#ff404010| +0&#ffd7ff255|a|b|X+2&#ff404010| +0&#ffd7ff255|Y+2&#ff404010|e+0&#ffd7ff255|f| @19
+| +0#0000e05#a8a8a8255@1|o+0#0000000#ffd7ff255|n|e| @31||+1&#ffffff0| +0#0000e05#a8a8a8255@1|o+0#0000000#ffd7ff255|n|e|w|o|r|d| |a|n|o|t|h|e|r| |w|o|r|d| @14
+| +0#0000e05#a8a8a8255@1|w+0#0000000#ffd7ff255|o|r|d| |a|n|o|t|h|e|r| |w|o|r|d| @17||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|a+0#0000000#5fd7ff255|d@1|i|t|i|o|n|a|l| |l|i|n|e| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+|~+0&#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_multiline_02.dump b/src/testdir/dumps/Test_diff_inline_multiline_02.dump
new file mode 100644 (file)
index 0000000..c7bf4cb
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multiline_02.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| @2|i|s| @25||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| |i|s| |s+2&#ff404010|o|m|e| +0&#ffd7ff255|t+2&#ff404010|e|s|t| +0&#ffd7ff255@17
+| +0#0000e05#a8a8a8255@1|s+2#0000000#ff404010|o|m|e|t|e|s|t| +0&#ffd7ff255|t+2&#ff404010|e|x|t| +0&#ffd7ff255|f+2&#ff404010|o@1| +0&#ffd7ff255@17||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+2#0000000#ff404010|e|x|t|s| +0&#ffd7ff255@29
+| +0#0000e05#a8a8a8255@1|b+2#0000000#ff404010|a|z| +0&#ffd7ff255|a+2&#ff404010|b|c| +0&#ffd7ff255|d+2&#ff404010|e|f| +0&#ffd7ff255@23||+1&#ffffff0| +0#0000e05#a8a8a8255@1|f+2#0000000#ff404010|o@1| +0&#ffd7ff255|b+2&#ff404010|a|r| +0&#ffd7ff255|a+2&#ff404010|b|X| +0&#ffd7ff255|Y+2&#ff404010|e|f| +0&#ffd7ff255@19
+| +0#0000e05#a8a8a8255@1|o+2#0000000#ff404010|n|e| +0&#ffd7ff255@31||+1&#ffffff0| +0#0000e05#a8a8a8255@1|o+2#0000000#ff404010|n|e|w|o|r|d| +0&#ffd7ff255|a|n|o|t|h|e|r| |w|o|r|d| @14
+| +0#0000e05#a8a8a8255@1|w+2#0000000#ff404010|o|r|d| +0&#ffd7ff255|a|n|o|t|h|e|r| |w|o|r|d| @17||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|a+0#0000000#5fd7ff255|d@1|i|t|i|o|n|a|l| |l|i|n|e| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+|~+0&#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_multiline_03.dump b/src/testdir/dumps/Test_diff_inline_multiline_03.dump
new file mode 100644 (file)
index 0000000..3cc0dbe
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multiline_03.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| | +0&#4040ff13@1|i+0&#ffd7ff255|s| @25||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| |i|s| |s|o|m|e| +0&#4040ff13|t+0&#ffd7ff255|e|s|t| @17
+| +0#0000e05#a8a8a8255@1|s+0#0000000#ffd7ff255|o|m|e|t|e|s|t| |t|e|x|t| |f|o@1| @17||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|e|x|t|s+0&#4040ff13| +0&#ffd7ff255@29
+| +0#0000e05#a8a8a8255@1|b+0#0000000#ffd7ff255|a|z+2&#ff404010| +0&#ffd7ff255|a|b|c+2&#ff404010| +0&#ffd7ff255|d+2&#ff404010|e+0&#ffd7ff255|f| @23||+1&#ffffff0| +0#0000e05#a8a8a8255@1|f+0#0000000#ffd7ff255|o@1| |b|a|r+2&#ff404010| +0&#ffd7ff255|a|b|X+2&#ff404010| +0&#ffd7ff255|Y+2&#ff404010|e+0&#ffd7ff255|f| @19
+| +0#0000e05#a8a8a8255@1|o+0#0000000#ffd7ff255|n|e| @31||+1&#ffffff0| +0#0000e05#a8a8a8255@1|o+0#0000000#ffd7ff255|n|e|w|o|r|d| |a|n|o|t|h|e|r| |w|o|r|d| @14
+| +0#0000e05#a8a8a8255@1|w+0#0000000#ffd7ff255|o|r|d| |a|n|o|t|h|e|r| |w|o|r|d| @17||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|a+0#0000000#5fd7ff255|d@1|i|t|i|o|n|a|l| |l|i|n|e| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+|~+0&#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_multiline_04.dump b/src/testdir/dumps/Test_diff_inline_multiline_04.dump
new file mode 100644 (file)
index 0000000..4aef70c
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multiline_04.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| | +0&#4040ff13@1|i+0&#ffd7ff255|s| @25||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| |i|s| |s+2&#ff404010|o|m|e| +0&#ffd7ff255|t+2&#ff404010|e|s|t| +0&#ffd7ff255@17
+| +0#0000e05#a8a8a8255@1|s+2#0000000#ff404010|o|m|e|t|e|s|t| +0&#ffd7ff255|t+2&#ff404010|e|x|t| +0&#ffd7ff255|f|o@1| @17||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+2#0000000#ff404010|e|x|t|s| +0&#ffd7ff255@29
+| +0#0000e05#a8a8a8255@1|b+2#0000000#ff404010|a|z| +0&#ffd7ff255|a+2&#ff404010|b|c| +0&#ffd7ff255|d+2&#ff404010|e|f| +0&#ffd7ff255@23||+1&#ffffff0| +0#0000e05#a8a8a8255@1|f+0#0000000#ffd7ff255|o@1| |b+2&#ff404010|a|r| +0&#ffd7ff255|a+2&#ff404010|b|X| +0&#ffd7ff255|Y+2&#ff404010|e|f| +0&#ffd7ff255@19
+| +0#0000e05#a8a8a8255@1|o+2#0000000#ff404010|n|e| +0&#ffd7ff255@31||+1&#ffffff0| +0#0000e05#a8a8a8255@1|o+2#0000000#ff404010|n|e|w|o|r|d| +0&#ffd7ff255|a|n|o|t|h|e|r| |w|o|r|d| @14
+| +0#0000e05#a8a8a8255@1|w+2#0000000#ff404010|o|r|d| +0&#ffd7ff255|a|n|o|t|h|e|r| |w|o|r|d| @17||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|a+0#0000000#5fd7ff255|d@1|i|t|i|o|n|a|l| |l|i|n|e| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+|~+0&#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_multiline_05.dump b/src/testdir/dumps/Test_diff_inline_multiline_05.dump
new file mode 100644 (file)
index 0000000..7ff92f7
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multiline_05.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| @2|i|s| @25||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| |i|s| |s|o|m|e| |t|e|s|t| @17
+| +0#0000e05#a8a8a8255@1|s+0#0000000#ffd7ff255|o|m|e|t|e|s|t| |t|e|x|t| |f|o@1| @17||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|e|x|t|s+0&#4040ff13| +0&#ffd7ff255@29
+| +0#0000e05#a8a8a8255@1|b+0#0000000#ffd7ff255|a|z+2&#ff404010| +0&#ffd7ff255|a|b|c+2&#ff404010| |d|e+0&#ffd7ff255|f| @23||+1&#ffffff0| +0#0000e05#a8a8a8255@1|f+0#0000000#ffd7ff255|o@1| |b|a|r+2&#ff404010| +0&#ffd7ff255|a|b|X+2&#ff404010| |Y|e+0&#ffd7ff255|f| @19
+| +0#0000e05#a8a8a8255@1|o+0#0000000#ffd7ff255|n|e| @31||+1&#ffffff0| +0#0000e05#a8a8a8255@1|o+0#0000000#ffd7ff255|n|e|w|o|r|d| |a|n|o|t|h|e|r| |w|o|r|d| @14
+| +0#0000e05#a8a8a8255@1|w+0#0000000#ffd7ff255|o|r|d| |a|n|o|t|h|e|r| |w|o|r|d| @17||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|a+0#0000000#5fd7ff255|d@1|i|t|i|o|n|a|l| |l|i|n|e| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+|~+0&#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_multiline_06.dump b/src/testdir/dumps/Test_diff_inline_multiline_06.dump
new file mode 100644 (file)
index 0000000..9a75667
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multiline_06.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| @2|i|s| @25||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| |i|s| |s+2&#ff404010|o|m|e| |t|e|s|t| +0&#ffd7ff255@17
+| +0#0000e05#a8a8a8255@1|s+2#0000000#ff404010|o|m|e|t|e|s|t| |t|e|x|t| +0&#ffd7ff255|f|o@1| @17||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+2#0000000#ff404010|e|x|t|s| +0&#ffd7ff255@29
+| +0#0000e05#a8a8a8255@1|b+2#0000000#ff404010|a|z| |a|b|c| |d|e|f| | +0&#ffd7ff255@22||+1&#ffffff0| +0#0000e05#a8a8a8255@1|f+0#0000000#ffd7ff255|o@1| |b+2&#ff404010|a|r| |a|b|X| |Y|e|f| @4| +0&#ffd7ff255@14
+| +0#0000e05#a8a8a8255@1|o+2#0000000#ff404010|n|e| +0&#ffd7ff255@31||+1&#ffffff0| +0#0000e05#a8a8a8255@1|o+2#0000000#ff404010|n|e|w|o|r|d| +0&#ffd7ff255|a|n|o|t|h|e|r| |w|o|r|d| @14
+| +0#0000e05#a8a8a8255@1|w+2#0000000#ff404010|o|r|d| +0&#ffd7ff255|a|n|o|t|h|e|r| |w|o|r|d| @17||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|a+0#0000000#5fd7ff255|d@1|i|t|i|o|n|a|l| |l|i|n|e| @19||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+|~+0&#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_multiline_07.dump b/src/testdir/dumps/Test_diff_inline_multiline_07.dump
new file mode 100644 (file)
index 0000000..de58a6a
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multiline_07.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| | +0&#4040ff13@1|i+0&#ffd7ff255|s| | +0&#4040ff13@1|$+0#4040ff13&| +0#0000000#ffd7ff255@21||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| |i|s| |s|o|m|e| +0&#4040ff13|t+0&#ffd7ff255|e|s|t|$+2#4040ff13#ff404010| +0#0000000#ffd7ff255@16
+| +0#0000e05#a8a8a8255@1|s+0#0000000#ffd7ff255|o|m|e|t|e|s|t| +2&#ff404010|t+0&#ffd7ff255|e|x|t| +2&#ff404010|f+0&#ffd7ff255|o@1|$+2#4040ff13#ff404010| +0#0000000#ffd7ff255@16||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|e|x|t|s+2&#ff404010|$+2#4040ff13&| +0#0000000#ffd7ff255@28
+| +0#0000e05#a8a8a8255@1|b+0#0000000#ffd7ff255|a|z+2&#ff404010| +0&#ffd7ff255|a|b|c+2&#ff404010| +0&#ffd7ff255|d+2&#ff404010|e+0&#ffd7ff255|f| |$+0#4040ff13&| +0#0000000&@21||+1&#ffffff0| +0#0000e05#a8a8a8255@1|f+0#0000000#ffd7ff255|o@1| +2&#ff404010|b+0&#ffd7ff255|a|r+2&#ff404010| +0&#ffd7ff255|a|b|X+2&#ff404010| +0&#ffd7ff255|Y+2&#ff404010|e+0&#ffd7ff255|f| | +0&#4040ff13@3|$+0#4040ff13#ffd7ff255| +0#0000000&@13
+| +0#0000e05#a8a8a8255@1|o+0#0000000#ffd7ff255|n|e|$+0#4040ff13#4040ff13| +0#0000000#ffd7ff255@30||+1&#ffffff0| +0#0000e05#a8a8a8255@1|o+0#0000000#ffd7ff255|n|e|w|o|r|d| |a|n|o|t|h|e|r| |w|o|r|d|$+0#4040ff13&| +0#0000000&@13
+| +0#0000e05#a8a8a8255@1|w+0#0000000#ffd7ff255|o|r|d| |a|n|o|t|h|e|r| |w|o|r|d|$+0#4040ff13&| +0#0000000&@16||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|a+0#0000000#5fd7ff255|d@1|i|t|i|o|n|a|l| |l|i|n|e|$+0#4040ff13&| +0#0000000&@18||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+|~+0&#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+1#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+3&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_multiline_08.dump b/src/testdir/dumps/Test_diff_inline_multiline_08.dump
new file mode 100644 (file)
index 0000000..901ea46
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multiline_08.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| @2|i|s| @2|$+0#4040ff13&| +0#0000000&@21||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| |i|s| |s|o|m|e| +0&#4040ff13|t+0&#ffd7ff255|e|s|t|$+0#4040ff13&| +0#0000000&@16
+| +0#0000e05#a8a8a8255@1|s+0#0000000#ffd7ff255|o|m|e|t|e|s|t| |t|e|x|t| |f|o@1|$+0#4040ff13&| +0#0000000&@16||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|e|x|t|s+0&#4040ff13|$+0#4040ff13#ffd7ff255| +0#0000000&@28
+| +0#0000e05#a8a8a8255@1|b+0#0000000#ffd7ff255|a|z+2&#ff404010| +0&#ffd7ff255|a|b|c+2&#ff404010| +0&#ffd7ff255|d+2&#ff404010|e+0&#ffd7ff255|f| |$+0#4040ff13&| +0#0000000&@21||+1&#ffffff0| +0#0000e05#a8a8a8255@1|f+0#0000000#ffd7ff255|o@1| |b|a|r+2&#ff404010| +0&#ffd7ff255|a|b|X+2&#ff404010| +0&#ffd7ff255|Y+2&#ff404010|e+0&#ffd7ff255|f| @4|$+0#4040ff13&| +0#0000000&@13
+| +0#0000e05#a8a8a8255@1|o+0#0000000#ffd7ff255|n|e|$+0#4040ff13#4040ff13| +0#0000000#ffd7ff255@30||+1&#ffffff0| +0#0000e05#a8a8a8255@1|o+0#0000000#ffd7ff255|n|e|w|o|r|d| |a|n|o|t|h|e|r| |w|o|r|d|$+0#4040ff13&| +0#0000000&@13
+| +0#0000e05#a8a8a8255@1|w+0#0000000#ffd7ff255|o|r|d| |a|n|o|t|h|e|r| |w|o|r|d|$+0#4040ff13&| +0#0000000&@16||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|a+0#0000000#5fd7ff255|d@1|i|t|i|o|n|a|l| |l|i|n|e|$+0#4040ff13&| +0#0000000&@18||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+|~+0&#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+1#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+3&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_multiline_09.dump b/src/testdir/dumps/Test_diff_inline_multiline_09.dump
new file mode 100644 (file)
index 0000000..91f59cd
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multiline_09.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| | +0&#4040ff13@1|i+0&#ffd7ff255|s| @2|$+0#4040ff13&| +0#0000000&@21||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| |i|s| |s|o|m|e| +0&#4040ff13|t+0&#ffd7ff255|e|s|t|$+0#4040ff13&| +0#0000000&@16
+| +0#0000e05#a8a8a8255@1|s+0#0000000#ffd7ff255|o|m|e|t|e|s|t| |t|e|x|t| |f|o@1|$+0#4040ff13&| +0#0000000&@16||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|e|x|t|s+0&#4040ff13|$+0#4040ff13#ffd7ff255| +0#0000000&@28
+| +0#0000e05#a8a8a8255@1|b+0#0000000#ffd7ff255|a|z+2&#ff404010| +0&#ffd7ff255|a|b|c+2&#ff404010| +0&#ffd7ff255|d+2&#ff404010|e+0&#ffd7ff255|f| |$+0#4040ff13&| +0#0000000&@21||+1&#ffffff0| +0#0000e05#a8a8a8255@1|f+0#0000000#ffd7ff255|o@1| |b|a|r+2&#ff404010| +0&#ffd7ff255|a|b|X+2&#ff404010| +0&#ffd7ff255|Y+2&#ff404010|e+0&#ffd7ff255|f| @4|$+0#4040ff13&| +0#0000000&@13
+| +0#0000e05#a8a8a8255@1|o+0#0000000#ffd7ff255|n|e|$+0#4040ff13#4040ff13| +0#0000000#ffd7ff255@30||+1&#ffffff0| +0#0000e05#a8a8a8255@1|o+0#0000000#ffd7ff255|n|e|w|o|r|d| |a|n|o|t|h|e|r| |w|o|r|d|$+0#4040ff13&| +0#0000000&@13
+| +0#0000e05#a8a8a8255@1|w+0#0000000#ffd7ff255|o|r|d| |a|n|o|t|h|e|r| |w|o|r|d|$+0#4040ff13&| +0#0000000&@16||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|a+0#0000000#5fd7ff255|d@1|i|t|i|o|n|a|l| |l|i|n|e|$+0#4040ff13&| +0#0000000&@18||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+|~+0&#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+1#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+3&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_multiline_10.dump b/src/testdir/dumps/Test_diff_inline_multiline_10.dump
new file mode 100644 (file)
index 0000000..212c247
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_multiline_10.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| @2|i|s| @2|$+0#4040ff13&| +0#0000000&@21||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|h|i|s| |i|s| |s|o|m|e| |t|e|s|t|$+0#4040ff13&| +0#0000000&@16
+| +0#0000e05#a8a8a8255@1|s+0#0000000#ffd7ff255|o|m|e|t|e|s|t| |t|e|x|t| |f|o@1|$+0#4040ff13&| +0#0000000&@16||+1&#ffffff0| +0#0000e05#a8a8a8255@1|t+0#0000000#ffd7ff255|e|x|t|s+0&#4040ff13|$+0#4040ff13#ffd7ff255| +0#0000000&@28
+| +0#0000e05#a8a8a8255@1|b+0#0000000#ffd7ff255|a|z+2&#ff404010| +0&#ffd7ff255|a|b|c+2&#ff404010| |d|e+0&#ffd7ff255|f| |$+0#4040ff13&| +0#0000000&@21||+1&#ffffff0| +0#0000e05#a8a8a8255@1|f+0#0000000#ffd7ff255|o@1| |b|a|r+2&#ff404010| +0&#ffd7ff255|a|b|X+2&#ff404010| |Y|e+0&#ffd7ff255|f| @4|$+0#4040ff13&| +0#0000000&@13
+| +0#0000e05#a8a8a8255@1|o+0#0000000#ffd7ff255|n|e|$+0#4040ff13&| +0#0000000&@30||+1&#ffffff0| +0#0000e05#a8a8a8255@1|o+0#0000000#ffd7ff255|n|e|w|o|r|d| |a|n|o|t|h|e|r| |w|o|r|d|$+0#4040ff13&| +0#0000000&@13
+| +0#0000e05#a8a8a8255@1|w+0#0000000#ffd7ff255|o|r|d| |a|n|o|t|h|e|r| |w|o|r|d|$+0#4040ff13&| +0#0000000&@16||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+| +0#0000e05#a8a8a8255@1|a+0#0000000#5fd7ff255|d@1|i|t|i|o|n|a|l| |l|i|n|e|$+0#4040ff13&| +0#0000000&@18||+1&#ffffff0| +0#0000e05#a8a8a8255@1|-+0#4040ff13#afffff255@34
+|~+0&#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+1#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+3&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_word_01.dump b/src/testdir/dumps/Test_diff_inline_word_01.dump
new file mode 100644 (file)
index 0000000..c7b7bdb
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_word_01.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|f+0#0000000#ffd7ff255|o@1|+|b+2&#ff404010|a|r| +0&#ffd7ff255|t|e|s|t| @22||+1&#ffffff0| +0#0000e05#a8a8a8255@1|f+0#0000000#ffd7ff255|o@1|+|b+2&#ff404010|a|z| +0&#ffd7ff255|t|e|s|t| @22
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/dumps/Test_diff_inline_word_02.dump b/src/testdir/dumps/Test_diff_inline_word_02.dump
new file mode 100644 (file)
index 0000000..db6865d
--- /dev/null
+++ b/src/testdir/dumps/Test_diff_inline_word_02.dump
@@ -0,0 +1,20 @@
+| +0#0000e05#a8a8a8255@1|f+2#0000000#ff404010|o@1|+|b|a|r| +0&#ffd7ff255|t|e|s|t| @22||+1&#ffffff0| +0#0000e05#a8a8a8255@1|f+2#0000000#ff404010|o@1|+|b|a|z| +0&#ffd7ff255|t|e|s|t| @22
+|~+0#4040ff13#ffffff0| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|~| @35||+1#0000000&|~+0#4040ff13&| @35
+|X+3#0000000&|d|i|f|i|l|e|1| @10|1|,|1| @11|A|l@1| |X+1&&|d|i|f|i|l|e|2| @10|1|,|1| @11|A|l@1
+|:+0&&> @73

diff --git a/src/testdir/gen_opt_test.vim b/src/testdir/gen_opt_test.vim
index b3a89a0f4673dc2396d9055bd871c7fc48a39348..8842454624c5a7ed1b91c02f46cd96ab22d125cb 100644 (file)
--- a/src/testdir/gen_opt_test.vim
+++ b/src/testdir/gen_opt_test.vim
@@ -182,10 +182,12 @@ let test_values = {
       \                'closeoff', 'hiddenoff', 'foldcolumn:0', 'foldcolumn:12',
       \                'followwrap', 'internal', 'indent-heuristic', 'algorithm:myers',
       \                'icase,iwhite', 'algorithm:minimal', 'algorithm:patience',
-      \                'algorithm:histogram', 'linematch:5'],
+      \                'algorithm:histogram', 'inline:none', 'inline:simple',
+      \                'inline:char', 'inline:word', 'inline:char,inline:word', 'linematch:5'],
       \                ['xxx', 'foldcolumn:', 'foldcolumn:x', 'foldcolumn:xxx',
       \                'linematch:', 'linematch:x', 'linematch:xxx', 'algorithm:',
-      \                'algorithm:xxx', 'context:', 'context:x', 'context:xxx']],
+      \                'algorithm:xxx', 'context:', 'context:x', 'context:xxx',
+      \                'inline:xxx']],
       \ 'display': [['', 'lastline', 'truncate', 'uhex', 'lastline,uhex'],
       \                ['xxx']],
       \ 'eadirection': [['', 'both', 'ver', 'hor'], ['xxx', 'ver,hor']],

diff --git a/src/testdir/test_diffmode.vim b/src/testdir/test_diffmode.vim
index b62266bb8aa65206b760c835e1b7cf4c11a5f74b..6c87da97c632f73fc8393bf483d75154eba7aa5b 100644 (file)
--- a/src/testdir/test_diffmode.vim
+++ b/src/testdir/test_diffmode.vim
@@ -430,13 +430,13 @@ endfunc
 
 func Common_icase_test()
   edit one
-  call setline(1, ['One', 'Two', 'Three', 'Four', 'Fi#ve'])
+  call setline(1, ['One', 'Two', 'Three', 'Four', 'Fi#vϵ', 'Si⃗x', 'Se⃗ve⃗n'])
   redraw
   let normattr = screenattr(1, 1)
   diffthis
 
   botright vert new two
-  call setline(1, ['one', 'TWO', 'Three ', 'Four', 'fI=VE'])
+  call setline(1, ['one', 'TWO', 'Three ', 'Four', 'fI=VΕ', 'SI⃗x', 'SEvE⃗n'])
   diffthis
 
   redraw
@@ -444,10 +444,13 @@ func Common_icase_test()
   call assert_equal(normattr, screenattr(2, 1))
   call assert_notequal(normattr, screenattr(3, 1))
   call assert_equal(normattr, screenattr(4, 1))
+  call assert_equal(normattr, screenattr(6, 2))
+  call assert_notequal(normattr, screenattr(7, 2))
 
   let dtextattr = screenattr(5, 3)
   call assert_notequal(dtextattr, screenattr(5, 1))
   call assert_notequal(dtextattr, screenattr(5, 5))
+  call assert_notequal(dtextattr, screenattr(7, 4))
 
   diffoff!
   %bwipe!
@@ -778,10 +781,10 @@ endfunc
 
 func Test_diff_hlID()
   new
-  call setline(1, [1, 2, 3])
+  call setline(1, [1, 2, 3, 'Yz', 'a dxxg',])
   diffthis
   vnew
-  call setline(1, ['1x', 2, 'x', 3])
+  call setline(1, ['1x', 2, 'x', 3, 'yx', 'abc defg'])
   diffthis
   redraw
 
@@ -792,6 +795,26 @@ func Test_diff_hlID()
   call diff_hlID(2, 1)->synIDattr("name")->assert_equal("")
   call diff_hlID(3, 1)->synIDattr("name")->assert_equal("DiffAdd")
   eval 4->diff_hlID(1)->synIDattr("name")->assert_equal("")
+  call diff_hlID(5, 1)->synIDattr("name")->assert_equal("DiffText")
+  call diff_hlID(5, 2)->synIDattr("name")->assert_equal("DiffText")
+
+  set diffopt+=icase " test that caching is invalidated by diffopt change
+  call diff_hlID(5, 1)->synIDattr("name")->assert_equal("DiffChange")
+  set diffopt-=icase
+  call diff_hlID(5, 1)->synIDattr("name")->assert_equal("DiffText")
+
+  call diff_hlID(6, 1)->synIDattr("name")->assert_equal("DiffChange")
+  call diff_hlID(6, 2)->synIDattr("name")->assert_equal("DiffText")
+  call diff_hlID(6, 4)->synIDattr("name")->assert_equal("DiffText")
+  call diff_hlID(6, 7)->synIDattr("name")->assert_equal("DiffText")
+  call diff_hlID(6, 8)->synIDattr("name")->assert_equal("DiffChange")
+  set diffopt+=inline:char
+  call diff_hlID(6, 1)->synIDattr("name")->assert_equal("DiffChange")
+  call diff_hlID(6, 2)->synIDattr("name")->assert_equal("DiffTextAdd")
+  call diff_hlID(6, 4)->synIDattr("name")->assert_equal("DiffChange")
+  call diff_hlID(6, 7)->synIDattr("name")->assert_equal("DiffText")
+  call diff_hlID(6, 8)->synIDattr("name")->assert_equal("DiffChange")
+  set diffopt-=inline:char
 
   wincmd w
   call assert_equal(synIDattr(diff_hlID(1, 1), "name"), "DiffChange")
@@ -2350,6 +2373,178 @@ func Test_diff_topline_noscroll()
   call StopVimInTerminal(buf)
 endfunc
 
+" Test inline highlighting which shows what's different within each diff block
+func Test_diff_inline()
+  CheckScreendump
+
+  call WriteDiffFiles(0, [], [])
+  let buf = RunVimInTerminal('-d Xdifile1 Xdifile2', {})
+  call term_sendkeys(buf, ":set autoread\<CR>\<c-w>w:set autoread\<CR>\<c-w>w")
+
+  call WriteDiffFiles(buf, ["abcdef ghi jk n", "x", "y"], ["aBcef gHi lm n", "y", "z"])
+  call VerifyInternal(buf, "Test_diff_inline_01", "")
+  call VerifyInternal(buf, "Test_diff_inline_02", " diffopt+=inline:none")
+
+  " inline:simple is the same as default
+  call VerifyInternal(buf, "Test_diff_inline_01", " diffopt+=inline:simple")
+
+  call VerifyInternal(buf, "Test_diff_inline_03", " diffopt+=inline:char")
+  call VerifyInternal(buf, "Test_diff_inline_04", " diffopt+=inline:word")
+
+  " multiple inline values will the last one
+  call VerifyInternal(buf, "Test_diff_inline_01", " diffopt+=inline:none,inline:char,inline:simple")
+  call VerifyInternal(buf, "Test_diff_inline_02", " diffopt+=inline:simple,inline:word,inline:none")
+  call VerifyInternal(buf, "Test_diff_inline_03", " diffopt+=inline:simple,inline:word,inline:char")
+
+  " DiffTextAdd highlight
+  call term_sendkeys(buf, ":hi DiffTextAdd ctermbg=blue\<CR>")
+  call VerifyInternal(buf, "Test_diff_inline_05", " diffopt+=inline:char")
+
+  " Live update in insert mode
+  call term_sendkeys(buf, "\<Esc>isometext")
+  call VerifyScreenDump(buf, "Test_diff_inline_06", {})
+  call term_sendkeys(buf, "\<Esc>u")
+
+  " icase simple scenarios
+  call VerifyInternal(buf, "Test_diff_inline_07", " diffopt+=inline:simple,icase")
+  call VerifyInternal(buf, "Test_diff_inline_08", " diffopt+=inline:char,icase")
+  call VerifyInternal(buf, "Test_diff_inline_09", " diffopt+=inline:word,icase")
+
+  " diff algorithms should affect highlight
+  call WriteDiffFiles(buf, ["apples and oranges"], ["oranges and apples"])
+  call VerifyInternal(buf, "Test_diff_inline_10", " diffopt+=inline:char")
+  call VerifyInternal(buf, "Test_diff_inline_11", " diffopt+=inline:char,algorithm:patience")
+
+  " icase: composing chars and Unicode fold case edge cases
+  call WriteDiffFiles(buf,
+        \ ["1 - sigma in 6σ and Ὀδυσσεύς", "1 - angstrom in åå", "1 - composing: ii⃗I⃗"],
+        \ ["2 - Sigma in 6Σ and ὈΔΥΣΣΕΎΣ", "2 - Angstrom in ÅÅ", "2 - Composing: i⃗I⃗I⃗"])
+  call VerifyInternal(buf, "Test_diff_inline_12", " diffopt+=inline:char")
+  call VerifyInternal(buf, "Test_diff_inline_13", " diffopt+=inline:char,icase")
+
+  " wide chars
+  call WriteDiffFiles(buf, ["abc😅xde一", "f🚀g"], ["abcy😢de", "二f🚀g"])
+  call VerifyInternal(buf, "Test_diff_inline_14", " diffopt+=inline:char,icase")
+
+  " NUL char (\n below is internally substituted as NUL)
+  call WriteDiffFiles(buf, ["1\n34\n5\n6"], ["1234\n5", "6"])
+  call VerifyInternal(buf, "Test_diff_inline_15", " diffopt+=inline:char")
+
+  " word diff: always use first buffer's iskeyword and ignore others' for consistency
+  call WriteDiffFiles(buf, ["foo+bar test"], ["foo+baz test"])
+  call VerifyInternal(buf, "Test_diff_inline_word_01", " diffopt+=inline:word")
+
+  call term_sendkeys(buf, ":set iskeyword+=+\<CR>:diffupdate\<CR>")
+  call VerifyInternal(buf, "Test_diff_inline_word_02", " diffopt+=inline:word")
+
+  call term_sendkeys(buf, ":set iskeyword&\<CR>:wincmd w\<CR>")
+  call term_sendkeys(buf, ":set iskeyword+=+\<CR>:wincmd w\<CR>:diffupdate\<CR>")
+  " Use the previous screen dump as 2nd buffer's iskeyword does not matter
+  call VerifyInternal(buf, "Test_diff_inline_word_01", " diffopt+=inline:word")
+
+  call term_sendkeys(buf, ":windo set iskeyword&\<CR>:1wincmd w\<CR>")
+
+  " char diff: should slide highlight to whitespace boundary if possible for
+  " better readability (by using forced indent-heuristics). A wrong result
+  " would be if the highlight is "Bar, prefix". It should be "prefixBar, "
+  " instead.
+  call WriteDiffFiles(buf, ["prefixFoo, prefixEnd"], ["prefixFoo, prefixBar, prefixEnd"])
+  call VerifyInternal(buf, "Test_diff_inline_char_01", " diffopt+=inline:char")
+
+  " char diff: small gaps between inline diff blocks will be merged during refine step
+  " - first segment: test that we iteratively merge small gaps after we merged
+  "   adjacent blocks, but only with limited number (set to 4) of iterations.
+  " - second and third segments: show that we need a large enough adjacent block to
+  "   trigger a merge.
+  " - fourth segment: small gaps are not merged when adjacent large block is
+  "   on a different line.
+  call WriteDiffFiles(buf,
+        \ ["abcdefghijklmno", "anchor1",
+        \  "abcdefghijklmno", "anchor2",
+        \  "abcdefghijklmno", "anchor3",
+        \  "test", "multiline"],
+        \ ["a?c?e?g?i?k???o",  "anchor1",
+        \  "a??de?????klmno",  "anchor2",
+        \  "a??de??????lmno", "anchor3",
+        \  "t?s?", "??????i?e"])
+  call VerifyInternal(buf, "Test_diff_inline_char_02", " diffopt+=inline:char")
+
+  " Test multi-line blocks and whitespace
+  call WriteDiffFiles(buf,
+        \ ["this   is   ", "sometest text foo", "baz abc def ", "one", "word another word", "additional line"],
+        \ ["this is some test", "texts", "foo bar abX Yef     ", "oneword another word"])
+  call VerifyInternal(buf, "Test_diff_inline_multiline_01", " diffopt+=inline:char,iwhite")
+  call VerifyInternal(buf, "Test_diff_inline_multiline_02", " diffopt+=inline:word,iwhite")
+  call VerifyInternal(buf, "Test_diff_inline_multiline_03", " diffopt+=inline:char,iwhiteeol")
+  call VerifyInternal(buf, "Test_diff_inline_multiline_04", " diffopt+=inline:word,iwhiteeol")
+  call VerifyInternal(buf, "Test_diff_inline_multiline_05", " diffopt+=inline:char,iwhiteall")
+  call VerifyInternal(buf, "Test_diff_inline_multiline_06", " diffopt+=inline:word,iwhiteall")
+
+  " newline should be highlighted too when 'list' is set
+  call term_sendkeys(buf, ":windo set list\<CR>")
+  call VerifyInternal(buf, "Test_diff_inline_multiline_07", " diffopt+=inline:char")
+  call VerifyInternal(buf, "Test_diff_inline_multiline_08", " diffopt+=inline:char,iwhite")
+  call VerifyInternal(buf, "Test_diff_inline_multiline_09", " diffopt+=inline:char,iwhiteeol")
+  call VerifyInternal(buf, "Test_diff_inline_multiline_10", " diffopt+=inline:char,iwhiteall")
+  call term_sendkeys(buf, ":windo set nolist\<CR>")
+
+  call StopVimInTerminal(buf)
+endfunc
+
+func Test_diff_inline_multibuffer()
+  CheckScreendump
+
+  call WriteDiffFiles3(0, [], [], [])
+  let buf = RunVimInTerminal('-d Xdifile1 Xdifile2 Xdifile3', {})
+  call term_sendkeys(buf, ":windo set autoread\<CR>:1wincmd w\<CR>")
+  call term_sendkeys(buf, ":hi DiffTextAdd ctermbg=blue\<CR>")
+
+  call WriteDiffFiles3(buf,
+        \ ["That is buffer1.", "anchor", "Some random text", "anchor"],
+        \ ["This is buffer2.", "anchor", "Some text", "anchor", "buffer2/3"],
+        \ ["This is buffer3. Last.", "anchor", "Some more", "text here.", "anchor", "only in buffer2/3", "not in buffer1"])
+  call VerifyInternal(buf, "Test_diff_inline_multibuffer_01", " diffopt+=inline:char")
+
+  " Close one of the buffer and make sure it updates correctly
+  call term_sendkeys(buf, ":diffoff\<CR>")
+  call VerifyInternal(buf, "Test_diff_inline_multibuffer_02", " diffopt+=inline:char")
+
+  " Update text in the non-diff buffer and nothing should be changed
+  call term_sendkeys(buf, "\<Esc>isometext")
+  call VerifyScreenDump(buf, "Test_diff_inline_multibuffer_03", {})
+  call term_sendkeys(buf, "\<Esc>u")
+
+  call term_sendkeys(buf, ":diffthis\<CR>")
+  call VerifyInternal(buf, "Test_diff_inline_multibuffer_01", " diffopt+=inline:char")
+
+  " Test that removing first buffer from diff will in turn use the next
+  " earliest buffer's iskeyword during word diff.
+  call WriteDiffFiles3(buf,
+        \ ["This+is=a-setence"],
+        \ ["This+is=another-setence"],
+        \ ["That+is=a-setence"])
+  call term_sendkeys(buf, ":set iskeyword+=+\<CR>:2wincmd w\<CR>:set iskeyword+=-\<CR>:1wincmd w\<CR>")
+  call VerifyInternal(buf, "Test_diff_inline_multibuffer_04", " diffopt+=inline:word")
+  call term_sendkeys(buf, ":diffoff\<CR>")
+  call VerifyInternal(buf, "Test_diff_inline_multibuffer_05", " diffopt+=inline:word")
+  call term_sendkeys(buf, ":diffthis\<CR>")
+  call VerifyInternal(buf, "Test_diff_inline_multibuffer_04", " diffopt+=inline:word")
+
+  " Test multi-buffer char diff refinement, and that removing a buffer from
+  " diff will update the others properly.
+  call WriteDiffFiles3(buf,
+        \ ["abcdefghijkYmYYY"],
+        \ ["aXXdXXghijklmnop"],
+        \ ["abcdefghijkYmYop"])
+  call VerifyInternal(buf, "Test_diff_inline_multibuffer_06", " diffopt+=inline:char")
+  call term_sendkeys(buf, ":diffoff\<CR>")
+  call VerifyInternal(buf, "Test_diff_inline_multibuffer_07", " diffopt+=inline:char")
+  call term_sendkeys(buf, ":diffthis\<CR>")
+  call VerifyInternal(buf, "Test_diff_inline_multibuffer_06", " diffopt+=inline:char")
+
+  call StopVimInTerminal(buf)
+endfunc
+
 func Test_diffget_diffput_linematch()
   CheckScreendump
   call delete('.Xdifile1.swp')

diff --git a/src/testdir/test_options.vim b/src/testdir/test_options.vim
index 6a561ac74dba5257d7017a414cd15fa94d94a224..2b90459b2dd1cf56d05262149ca6b24aa59abcfd 100644 (file)
--- a/src/testdir/test_options.vim
+++ b/src/testdir/test_options.vim
@@ -612,10 +612,11 @@ func Test_set_completion_string_values()
   call assert_equal([], getcompletion('set completepopup=bogusname:', 'cmdline'))
   set previewpopup& completepopup&
 
-  " diffopt: special handling of algorithm:<alg_list>
+  " diffopt: special handling of algorithm:<alg_list> and inline:<inline_type>
   call assert_equal('filler', getcompletion('set diffopt+=', 'cmdline')[0])
   call assert_equal([], getcompletion('set diffopt+=iblank,foldcolumn:', 'cmdline'))
   call assert_equal('patience', getcompletion('set diffopt+=iblank,algorithm:pat*', 'cmdline')[0])
+  call assert_equal('char', getcompletion('set diffopt+=iwhite,inline:ch*', 'cmdline')[0])
 
   " highlight: special parsing, including auto-completing highlight groups
   " after ':'
@@ -705,7 +706,7 @@ func Test_set_completion_string_values()
   call assert_equal([], getcompletion('set diffopt-=', 'cmdline'))
   " Test all possible values
   call assert_equal(['filler', 'context:', 'iblank', 'icase', 'iwhite', 'iwhiteall', 'iwhiteeol', 'horizontal',
-        \ 'vertical', 'closeoff', 'hiddenoff', 'foldcolumn:', 'followwrap', 'internal', 'indent-heuristic', 'algorithm:', 'linematch:'],
+        \ 'vertical', 'closeoff', 'hiddenoff', 'foldcolumn:', 'followwrap', 'internal', 'indent-heuristic', 'algorithm:', 'inline:', 'linematch:'],
         \ getcompletion('set diffopt=', 'cmdline'))
   set diffopt&
 

diff --git a/src/version.c b/src/version.c
index db9588e6cb884a739b3a6f0ec4b8b9cbe701374b..946c11e04c19864649bcf81a123e0c06b9069c55 100644 (file)
--- a/src/version.c
+++ b/src/version.c
@@ -704,6 +704,8 @@ static char *(features[]) =
 
 static int included_patches[] =
 {   /* Add new patch number below this line */
+/**/
+    1243,
 /**/
     1242,
 /**/

diff --git a/src/vim.h b/src/vim.h
index 55b901132f182ba75e57fb48571470f66e016ea1..29c3cb8880da563fa541cd5bccd6450896dd2d35 100644 (file)
--- a/src/vim.h
+++ b/src/vim.h
@@ -1517,7 +1517,8 @@ typedef enum
     , HLF_ADD      // Added diff line
     , HLF_CHD      // Changed diff line
     , HLF_DED      // Deleted diff line
-    , HLF_TXD      // Text Changed in diff line
+    , HLF_TXD      // Text Changed in changed diff line
+    , HLF_TXA      // Text Added in changed diff line
     , HLF_CONCEAL   // Concealed text
     , HLF_SC       // Sign column
     , HLF_SPB      // SpellBad
@@ -1551,7 +1552,7 @@ typedef enum
 // When changing this also adjust the default for 'highlight'.
 #define HL_FLAGS {'8', '~', '@', 'd', 'e', 'h', 'i', 'l', 'y', 'm', 'M', \
                  'n', 'a', 'b', 'N', 'G', 'O', 'r', 's', 'S', 'c', 't', 'v', 'V', \
-                 'w', 'W', 'f', 'F', 'A', 'C', 'D', 'T', '-', '>', \
+                 'w', 'W', 'f', 'F', 'A', 'C', 'D', 'T', 'E', '-', '>', \
                  'B', 'P', 'R', 'L', \
                  '+', '=', 'k', '<','[', ']', '{', '}', 'x', 'X', \
                  '*', '#', '_', '!', '.', 'o', 'q', \