xdiff: support external hunks via xpparam_t

Add two new xpparam_t fields (external_hunks, external_hunks_nr)
that let callers supply pre-computed hunks.  When set, xdl_diff()
populates the changed[] arrays from these hunks instead of running
the diff algorithm, then continues through compaction and emission
as usual.

Validate supplied hunks before use.  Out-of-bounds line numbers,
overlapping or out-of-order hunks, and misaligned unchanged runs are
treated as a malformed tool response: xdl_populate_hunks_from_external()
warns, returns -1, and xdl_diff() falls back to the builtin diff
algorithm for that file.  The run of unchanged lines between two hunks
(and before the first and after the last) must be the same length on
both sides; xdl_build_script() walks the two files in lockstep over
unchanged lines, so a balanced total is not enough.  Non-negative
counts and 1-based starts are instead caller preconditions, checked
with BUG(), since the caller normalizes hunks before this point.

On rejection xdl_diff() frees the environment it prepared and falls
through to xdl_do_diff(), which prepares a fresh one for the builtin
pass.

Skip trim_common_tail() in xdi_diff() when external hunks are
present, since external hunks reference line numbers in the
original content.

Signed-off-by: Michael Montalbo <mmontalbo@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/xdiff-interface.c b/xdiff-interface.c
index 686db8bb8b6710fd6558b2853383a24ba2b2b53a..cef8dc5b9b492e359ccfa461996c9ac6c8f4d06a 100644 (file)
--- a/xdiff-interface.c
+++ b/xdiff-interface.c
@@ -143,7 +143,12 @@ int xdi_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp, xdemitconf_t co
        if (mf1->size > MAX_XDIFF_SIZE || mf2->size > MAX_XDIFF_SIZE)
                return -1;
 
-       if (!xecfg->ctxlen && !(xecfg->flags & XDL_EMIT_FUNCCONTEXT))
+       /*
+        * External hunks reference line numbers in the original content;
+        * trimming the tail would change line counts and invalidate them.
+        */
+       if (!xpp->external_hunks &&
+           !xecfg->ctxlen && !(xecfg->flags & XDL_EMIT_FUNCCONTEXT))
                trim_common_tail(&a, &b);
 
        return xdl_diff(&a, &b, xpp, xecfg, xecb);

diff --git a/xdiff/xdiff.h b/xdiff/xdiff.h
index dc370712e9286098d4fbf487d183cc276e5a4462..4736bcdb07f16a8f84ab4f5b7f051ccfce0770b6 100644 (file)
--- a/xdiff/xdiff.h
+++ b/xdiff/xdiff.h
@@ -78,6 +78,18 @@ typedef struct s_mmbuffer {
        long size;
 } mmbuffer_t;
 
+/*
+ * Hunk descriptor for externally computed diffs, in xdiff's own
+ * coordinates: line numbers are 1-based and a hunk's start is the
+ * first line it covers.  A caller translates any external "empty side"
+ * idiom (such as git diff's start-0/count-0) to a 1-based start before
+ * handing hunks over.
+ */
+struct xdl_hunk {
+       long old_start, old_count;
+       long new_start, new_count;
+};
+
 typedef struct s_xpparam {
        unsigned long flags;
 
@@ -88,6 +100,10 @@ typedef struct s_xpparam {
        /* See Documentation/diff-options.adoc. */
        char **anchors;
        size_t anchors_nr;
+
+       /* Externally computed hunks: bypass the diff algorithm.  Owned by caller. */
+       struct xdl_hunk *external_hunks;
+       size_t external_hunks_nr;
 } xpparam_t;
 
 typedef struct s_xdemitcb {

diff --git a/xdiff/xdiffi.c b/xdiff/xdiffi.c
index c5a892f91e00c0e38e033942d11103adab16c026..73a456f5dd6d2886a395e163a431d30d80a4647e 100644 (file)
--- a/xdiff/xdiffi.c
+++ b/xdiff/xdiffi.c
@@ -1085,16 +1085,96 @@ static void xdl_mark_ignorable_regex(xdchange_t *xscr, const xdfenv_t *xe,
        }
 }
 
+/*
+ * Populate the changed[] arrays from externally supplied hunks,
+ * bypassing the diff algorithm.  The caller normalizes and validates
+ * the hunks first (order, overlap, and lockstep alignment), so this
+ * only marks lines changed after asserting the memory-safety
+ * preconditions it depends on: non-negative counts and 1-based starts
+ * (checked with BUG()), and an in-bounds range (a silent -1 so the
+ * caller can fall back to the builtin diff rather than index changed[]
+ * out of range).  Keeping this diagnostic-free leaves user-facing
+ * messages to the git layer.
+ *
+ * Returns 0 on success, -1 if a hunk is out of range.
+ */
+static int xdl_populate_hunks_from_external(xdfenv_t *xe,
+                                           struct xdl_hunk *hunks,
+                                           size_t nr_hunks)
+{
+       size_t i;
+       long j;
+
+       /*
+        * xdl_prepare_env() may dirty changed[] via xdl_cleanup_records().
+        * Clear them so only the external hunks are marked.
+        */
+       xdl_clear_changed(&xe->xdf1);
+       xdl_clear_changed(&xe->xdf2);
+
+       for (i = 0; i < nr_hunks; i++) {
+               struct xdl_hunk *h = &hunks[i];
+
+               /*
+                * Non-negative counts and 1-based starts are caller
+                * preconditions (it normalizes hunks into xdiff coordinates
+                * before this point), so a violation is a bug, not a bad
+                * tool response.
+                */
+               if (h->old_count < 0 || h->new_count < 0)
+                       BUG("external hunk %"PRIuMAX": "
+                               "negative count (old=%ld, new=%ld)",
+                               (uintmax_t)(i + 1),
+                               h->old_count, h->new_count);
+               if (h->old_start < 1 || h->new_start < 1)
+                       BUG("external hunk %"PRIuMAX": "
+                               "start not 1-based (old=%ld, new=%ld)",
+                               (uintmax_t)(i + 1),
+                               h->old_start, h->new_start);
+
+               /*
+                * The caller validates ordering, overlap and lockstep
+                * alignment (and diagnoses a bad response).  This is only a
+                * silent in-bounds guard so the marking loop cannot index
+                * changed[] out of range: start + count - 1 <= nrec,
+                * rewritten to avoid overflow.  A count of 0 (pure
+                * insert/delete) allows start == nrec + 1, the position
+                * after the last line.  On a miss, return -1 and let the
+                * caller fall back to the builtin diff.
+                */
+               if (h->old_count > (long)xe->xdf1.nrec - h->old_start + 1 ||
+                   h->new_count > (long)xe->xdf2.nrec - h->new_start + 1)
+                       return -1;
+
+               for (j = 0; j < h->old_count; j++)
+                       xe->xdf1.changed[h->old_start - 1 + j] = true;
+               for (j = 0; j < h->new_count; j++)
+                       xe->xdf2.changed[h->new_start - 1 + j] = true;
+       }
+
+       return 0;
+}
+
 int xdl_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
             xdemitconf_t const *xecfg, xdemitcb_t *ecb) {
        xdchange_t *xscr;
        xdfenv_t xe;
        emit_func_t ef = xecfg->hunk_func ? xdl_call_hunk_func : xdl_emit_diff;
 
-       if (xdl_do_diff(mf1, mf2, xpp, &xe) < 0) {
+       if (xpp->external_hunks) {
+               if (xdl_prepare_env(mf1, mf2, xpp, &xe) < 0)
+                       return -1;
+               if (xdl_populate_hunks_from_external(&xe,
+                                                    xpp->external_hunks,
+                                                    xpp->external_hunks_nr) == 0)
+                       goto diff_done;
+               xdl_free_env(&xe);
+       }
 
+       if (xdl_do_diff(mf1, mf2, xpp, &xe) < 0)
                return -1;
-       }
+
+diff_done:
        if (xdl_change_compact(&xe.xdf1, &xe.xdf2, xpp->flags) < 0 ||
            xdl_change_compact(&xe.xdf2, &xe.xdf1, xpp->flags) < 0 ||
            xdl_build_script(&xe, &xscr) < 0) {

diff --git a/xdiff/xprepare.c b/xdiff/xprepare.c
index 11bada2608a7a4abf44d3f1393b6880d02eb185c..f4ab93533286da5c1c89dc53ece77666e6cf0b3f 100644 (file)
--- a/xdiff/xprepare.c
+++ b/xdiff/xprepare.c
@@ -471,3 +471,13 @@ int xdl_prepare_env(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
 
        return 0;
 }
+
+/*
+ * Reset the changed[] array so that no lines are marked as changed.
+ * Also clears the sentinel slots at changed[-1] and changed[nrec]
+ * that xdl_change_compact() relies on during backward scans.
+ */
+void xdl_clear_changed(xdfile_t *xdf)
+{
+       memset(xdf->changed - 1, 0, (xdf->nrec + 2) * sizeof(bool));
+}

diff --git a/xdiff/xprepare.h b/xdiff/xprepare.h
index 947d9fc1bb8cf95719284de6563227485907988f..0413baf07bcc90655210a4c1f5f0dbce5ddf8ac4 100644 (file)
--- a/xdiff/xprepare.h
+++ b/xdiff/xprepare.h
@@ -28,6 +28,7 @@
 int xdl_prepare_env(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
                    xdfenv_t *xe);
 void xdl_free_env(xdfenv_t *xe);
+void xdl_clear_changed(xdfile_t *xdf);