xdiff: provide a separate emit callback for hunks

The xdiff library always emits hunk header lines to our callbacks as
formatted strings like "@@ -a,b +c,d @@\n". This is convenient if we're
going to output a diff, but less so if we actually need to compute using
those numbers, which requires re-parsing the line.

In preparation for moving away from this, let's teach xdiff a new
callback function which gets the broken-out hunk information. To help
callers that don't want to use this new callback, if it's NULL we'll
continue to format the hunk header into a string.

Note that this function renames the "outf" callback to "out_line", as
well. This isn't strictly necessary, but helps in two ways:

1. Now that there are two callbacks, it's nice to use more descriptive
names.

2. Many callers did not zero the emit_callback_data struct, and needed
to be modified to set ecb.out_hunk to NULL. By changing the name of
the existing struct member, that guarantees that any new callers
from in-flight topics will break the build and be examined
manually.

Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/merge-tree.c b/builtin/merge-tree.c
index f8023bae1e2eceaa8ea086f5d990d8bc4c0e6121..e7771a1012fb1a6c907aaadd0a178832d4ffe2a6 100644 (file)
--- a/builtin/merge-tree.c
+++ b/builtin/merge-tree.c
@@ -110,7 +110,8 @@ static void show_diff(struct merge_list *entry)
        xpp.flags = 0;
        memset(&xecfg, 0, sizeof(xecfg));
        xecfg.ctxlen = 3;
        xpp.flags = 0;
        memset(&xecfg, 0, sizeof(xecfg));
        xecfg.ctxlen = 3;

-       ecb.outf = show_outf;
+       ecb.out_hunk = NULL;
+       ecb.out_line = show_outf;

        ecb.priv = NULL;
 
        src.ptr = origin(entry, &size);
        ecb.priv = NULL;
 
        src.ptr = origin(entry, &size);

diff --git a/builtin/rerere.c b/builtin/rerere.c
index 0bc40298c2417a6d1f25aafb4b3577243e985c57..ea409e80cb32588cc0c319184754e410a21a0d49 100644 (file)
--- a/builtin/rerere.c
+++ b/builtin/rerere.c
@@ -41,7 +41,8 @@ static int diff_two(const char *file1, const char *label1,
        xpp.flags = 0;
        memset(&xecfg, 0, sizeof(xecfg));
        xecfg.ctxlen = 3;
        xpp.flags = 0;
        memset(&xecfg, 0, sizeof(xecfg));
        xecfg.ctxlen = 3;

-       ecb.outf = outf;
+       ecb.out_hunk = NULL;
+       ecb.out_line = outf;

        ret = xdi_diff(&minus, &plus, &xpp, &xecfg, &ecb);
 
        free(minus.ptr);
        ret = xdi_diff(&minus, &plus, &xpp, &xecfg, &ecb);
 
        free(minus.ptr);

diff --git a/xdiff-interface.c b/xdiff-interface.c
index ec6e574e4aa07414b9a17bb99ddee26fd44497de..88d96d78e67e14570066d079f1570bc3688eb651 100644 (file)
--- a/xdiff-interface.c
+++ b/xdiff-interface.c
@@ -152,7 +152,7 @@ int xdi_diff_outf(mmfile_t *mf1, mmfile_t *mf2,
        state.consume = fn;
        state.consume_callback_data = consume_callback_data;
        memset(&ecb, 0, sizeof(ecb));
        state.consume = fn;
        state.consume_callback_data = consume_callback_data;
        memset(&ecb, 0, sizeof(ecb));

-       ecb.outf = xdiff_outf;
+       ecb.out_line = xdiff_outf;

        ecb.priv = &state;
        strbuf_init(&state.remainder, 0);
        ret = xdi_diff(mf1, mf2, xpp, xecfg, &ecb);
        ecb.priv = &state;
        strbuf_init(&state.remainder, 0);
        ret = xdi_diff(mf1, mf2, xpp, xecfg, &ecb);

diff --git a/xdiff/xdiff.h b/xdiff/xdiff.h
index 2356da5f784fbe5670b3f9e8bbc6d6419b4fa9d3..b1583690208096f7bb75e0aa67cacc3179da1185 100644 (file)
--- a/xdiff/xdiff.h
+++ b/xdiff/xdiff.h
@@ -86,7 +86,11 @@ typedef struct s_xpparam {
 
 typedef struct s_xdemitcb {
        void *priv;
 
 typedef struct s_xdemitcb {
        void *priv;

-       int (*outf)(void *, mmbuffer_t *, int);
+       int (*out_hunk)(void *,
+                       long old_begin, long old_nr,
+                       long new_begin, long new_nr,
+                       const char *func, long funclen);
+       int (*out_line)(void *, mmbuffer_t *, int);

 } xdemitcb_t;
 
 typedef long (*find_func_t)(const char *line, long line_len, char *buffer, long buffer_size, void *priv);
 } xdemitcb_t;
 
 typedef long (*find_func_t)(const char *line, long line_len, char *buffer, long buffer_size, void *priv);

diff --git a/xdiff/xutils.c b/xdiff/xutils.c
index 88e5995535467475216de82b1eeb744e744f3b4d..963e1c58b9049f1b9ee94537171bd3c6cd21680f 100644 (file)
--- a/xdiff/xutils.c
+++ b/xdiff/xutils.c
@@ -54,7 +54,7 @@ int xdl_emit_diffrec(char const *rec, long size, char const *pre, long psize,
                mb[2].size = strlen(mb[2].ptr);
                i++;
        }
                mb[2].size = strlen(mb[2].ptr);
                i++;
        }

-       if (ecb->outf(ecb->priv, mb, i) < 0) {
+       if (ecb->out_line(ecb->priv, mb, i) < 0) {

 
                return -1;
        }
 
                return -1;
        }


@@ -344,8 +344,9 @@ int xdl_num_out(char *out, long val) {
        return str - out;
 }
 
        return str - out;
 }
 

-int xdl_emit_hunk_hdr(long s1, long c1, long s2, long c2,
-                     const char *func, long funclen, xdemitcb_t *ecb) {
+static int xdl_format_hunk_hdr(long s1, long c1, long s2, long c2,
+                              const char *func, long funclen,
+                              xdemitcb_t *ecb) {

        int nb = 0;
        mmbuffer_t mb;
        char buf[128];
        int nb = 0;
        mmbuffer_t mb;
        char buf[128];


@@ -387,9 +388,21 @@ int xdl_emit_hunk_hdr(long s1, long c1, long s2, long c2,
 
        mb.ptr = buf;
        mb.size = nb;
 
        mb.ptr = buf;
        mb.size = nb;

-       if (ecb->outf(ecb->priv, &mb, 1) < 0)
+       if (ecb->out_line(ecb->priv, &mb, 1) < 0)

                return -1;
                return -1;

+       return 0;
+}

 
 

+int xdl_emit_hunk_hdr(long s1, long c1, long s2, long c2,
+                     const char *func, long funclen,
+                     xdemitcb_t *ecb) {
+       if (!ecb->out_hunk)
+               return xdl_format_hunk_hdr(s1, c1, s2, c2, func, funclen, ecb);
+       if (ecb->out_hunk(ecb->priv,
+                         c1 ? s1 : s1 - 1, c1,
+                         c2 ? s2 : s2 - 1, c2,
+                         func, funclen) < 0)
+               return -1;

        return 0;
 }
 
        return 0;
 }