patch 9.0.1418: the included xdiff code is a bit outdated

Problem:    The included xdiff code is a bit outdated.
Solution:   Sync with the latest git xdiff code. (Yee Cheng Chin,
            closes #12181)

diff --git a/src/version.c b/src/version.c
index e20eb0697bb14060d1b83f6aba90588a54f3270a..45be73e13d2172454ec54914e80ec7623fec005e 100644 (file)
--- a/src/version.c
+++ b/src/version.c
@@ -695,6 +695,8 @@ static char *(features[]) =
 
 static int included_patches[] =
 {   /* Add new patch number below this line */
+/**/
+    1418,
 /**/
     1417,
 /**/

diff --git a/src/xdiff/README.txt b/src/xdiff/README.txt
index 9e01a3c679fb9334503b951b8f97f804b4ba26f5..3302abc24daccace636552b7a578ba00e9310ebe 100644 (file)
--- a/src/xdiff/README.txt
+++ b/src/xdiff/README.txt
@@ -1,6 +1,6 @@
 The files in this directory come from the xdiff implementation in git.
 You can find it here: https://github.com/git/git/tree/master/xdiff
-The files were last updated August 31, 2021 from git release v.2.33.0
+The files were last updated March 17, 2023 from git release v.2.40.0
 
 This is originally based on libxdiff, which can be found here:
 http://www.xmailserver.org/xdiff-lib.html

diff --git a/src/xdiff/xdiff.h b/src/xdiff/xdiff.h
index 3994f66fee65045cb6e65314cd871dcb812a0353..a9169d30ce96964900d943e740290ec13ec5adda 100644 (file)
--- a/src/xdiff/xdiff.h
+++ b/src/xdiff/xdiff.h
@@ -66,6 +66,7 @@ extern "C" {
 
 /* merge output styles */
 #define XDL_MERGE_DIFF3 1
+#define XDL_MERGE_ZEALOUS_DIFF3 2
 
 typedef struct s_mmfile {
        char *ptr;
@@ -126,6 +127,7 @@ typedef struct s_bdiffparam {
 #endif
 
 #define xdl_malloc(x) lalloc((x), TRUE)
+#define xdl_calloc(n, sz) lalloc_clear(n*sz, TRUE)
 #define xdl_free(ptr) vim_free(ptr)
 #define xdl_realloc(ptr,x) vim_realloc((ptr),(x))
 

diff --git a/src/xdiff/xdiffi.c b/src/xdiff/xdiffi.c
index cfcbb5d9826f27b72a9c58a23528f4d0c5a5c7bc..5a6f0cdcd3a13b6f667093d8bf9afdf5e4dcc1b8 100644 (file)
--- a/src/xdiff/xdiffi.c
+++ b/src/xdiff/xdiffi.c
@@ -315,16 +315,19 @@ int xdl_do_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
        long *kvd, *kvdf, *kvdb;
        xdalgoenv_t xenv;
        diffdata_t dd1, dd2;
+       int res;
 
-       if (XDF_DIFF_ALG(xpp->flags) == XDF_PATIENCE_DIFF)
-               return xdl_do_patience_diff(mf1, mf2, xpp, xe);
-
-       if (XDF_DIFF_ALG(xpp->flags) == XDF_HISTOGRAM_DIFF)
-               return xdl_do_histogram_diff(mf1, mf2, xpp, xe);
+       if (xdl_prepare_env(mf1, mf2, xpp, xe) < 0)
+               return -1;
 
-       if (xdl_prepare_env(mf1, mf2, xpp, xe) < 0) {
+       if (XDF_DIFF_ALG(xpp->flags) == XDF_PATIENCE_DIFF) {
+               res = xdl_do_patience_diff(xpp, xe);
+               goto out;
+       }
 
-               return -1;
+       if (XDF_DIFF_ALG(xpp->flags) == XDF_HISTOGRAM_DIFF) {
+               res = xdl_do_histogram_diff(xpp, xe);
+               goto out;
        }
 
        /*
@@ -334,7 +337,7 @@ int xdl_do_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
         * One is to store the forward path and one to store the backward path.
         */
        ndiags = xe->xdf1.nreff + xe->xdf2.nreff + 3;
-       if (!(kvd = (long *) xdl_malloc((2 * ndiags + 2) * sizeof(long)))) {
+       if (!XDL_ALLOC_ARRAY(kvd, 2 * ndiags + 2)) {
 
                xdl_free_env(xe);
                return -1;
@@ -359,17 +362,15 @@ int xdl_do_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
        dd2.rchg = xe->xdf2.rchg;
        dd2.rindex = xe->xdf2.rindex;
 
-       if (xdl_recs_cmp(&dd1, 0, dd1.nrec, &dd2, 0, dd2.nrec,
-                        kvdf, kvdb, (xpp->flags & XDF_NEED_MINIMAL) != 0, &xenv) < 0) {
-
-               xdl_free(kvd);
-               xdl_free_env(xe);
-               return -1;
-       }
-
+       res = xdl_recs_cmp(&dd1, 0, dd1.nrec, &dd2, 0, dd2.nrec,
+                          kvdf, kvdb, (xpp->flags & XDF_NEED_MINIMAL) != 0,
+                          &xenv);
        xdl_free(kvd);
+ out:
+       if (res < 0)
+               xdl_free_env(xe);
 
-       return 0;
+       return res;
 }
 
 
@@ -390,12 +391,9 @@ static xdchange_t *xdl_add_change(xdchange_t *xscr, long i1, long i2, long chg1,
 }
 
 
-static int recs_match(xrecord_t *rec1, xrecord_t *rec2, long flags)
+static int recs_match(xrecord_t *rec1, xrecord_t *rec2)
 {
-       return (rec1->ha == rec2->ha &&
-               xdl_recmatch(rec1->ptr, rec1->size,
-                            rec2->ptr, rec2->size,
-                            flags));
+       return (rec1->ha == rec2->ha);
 }
 
 /*
@@ -759,10 +757,10 @@ static inline int group_previous(xdfile_t *xdf, struct xdlgroup *g)
  * following group, expand this group to include it. Return 0 on success or -1
  * if g cannot be slid down.
  */
-static int group_slide_down(xdfile_t *xdf, struct xdlgroup *g, long flags)
+static int group_slide_down(xdfile_t *xdf, struct xdlgroup *g)
 {
        if (g->end < xdf->nrec &&
-           recs_match(xdf->recs[g->start], xdf->recs[g->end], flags)) {
+           recs_match(xdf->recs[g->start], xdf->recs[g->end])) {
                xdf->rchg[g->start++] = 0;
                xdf->rchg[g->end++] = 1;
 
@@ -780,10 +778,10 @@ static int group_slide_down(xdfile_t *xdf, struct xdlgroup *g, long flags)
  * into a previous group, expand this group to include it. Return 0 on success
  * or -1 if g cannot be slid up.
  */
-static int group_slide_up(xdfile_t *xdf, struct xdlgroup *g, long flags)
+static int group_slide_up(xdfile_t *xdf, struct xdlgroup *g)
 {
        if (g->start > 0 &&
-           recs_match(xdf->recs[g->start - 1], xdf->recs[g->end - 1], flags)) {
+           recs_match(xdf->recs[g->start - 1], xdf->recs[g->end - 1])) {
                xdf->rchg[--g->start] = 1;
                xdf->rchg[--g->end] = 0;
 
@@ -839,7 +837,7 @@ int xdl_change_compact(xdfile_t *xdf, xdfile_t *xdfo, long flags) {
                        end_matching_other = -1;
 
                        /* Shift the group backward as much as possible: */
-                       while (!group_slide_up(xdf, &g, flags))
+                       while (!group_slide_up(xdf, &g))
                                if (group_previous(xdfo, &go))
                                        xdl_bug("group sync broken sliding up");
 
@@ -854,7 +852,7 @@ int xdl_change_compact(xdfile_t *xdf, xdfile_t *xdfo, long flags) {
 
                        /* Now shift the group forward as far as possible: */
                        while (1) {
-                               if (group_slide_down(xdf, &g, flags))
+                               if (group_slide_down(xdf, &g))
                                        break;
                                if (group_next(xdfo, &go))
                                        xdl_bug("group sync broken sliding down");
@@ -881,7 +879,7 @@ int xdl_change_compact(xdfile_t *xdf, xdfile_t *xdfo, long flags) {
                         * other file that it can align with.
                         */
                        while (go.end == go.start) {
-                               if (group_slide_up(xdf, &g, flags))
+                               if (group_slide_up(xdf, &g))
                                        xdl_bug("match disappeared");
                                if (group_previous(xdfo, &go))
                                        xdl_bug("group sync broken sliding to match");
@@ -924,7 +922,7 @@ int xdl_change_compact(xdfile_t *xdf, xdfile_t *xdfo, long flags) {
                        }
 
                        while (g.end > best_shift) {
-                               if (group_slide_up(xdf, &g, flags))
+                               if (group_slide_up(xdf, &g))
                                        xdl_bug("best shift unreached");
                                if (group_previous(xdfo, &go))
                                        xdl_bug("group sync broken sliding to blank line");

diff --git a/src/xdiff/xdiffi.h b/src/xdiff/xdiffi.h
index 8f1c7c8b0445f88514d0cb0ce868380d1711ccd2..126c9d8ff4e4147e0f4e96ddb9debfde17d9b637 100644 (file)
--- a/src/xdiff/xdiffi.h
+++ b/src/xdiff/xdiffi.h
@@ -56,9 +56,7 @@ int xdl_build_script(xdfenv_t *xe, xdchange_t **xscr);
 void xdl_free_script(xdchange_t *xscr);
 int xdl_emit_diff(xdfenv_t *xe, xdchange_t *xscr, xdemitcb_t *ecb,
                  xdemitconf_t const *xecfg);
-int xdl_do_patience_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
-               xdfenv_t *env);
-int xdl_do_histogram_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
-               xdfenv_t *env);
+int xdl_do_patience_diff(xpparam_t const *xpp, xdfenv_t *env);
+int xdl_do_histogram_diff(xpparam_t const *xpp, xdfenv_t *env);
 
 #endif /* #if !defined(XDIFFI_H) */

diff --git a/src/xdiff/xemit.c b/src/xdiff/xemit.c
index b578e7a9d5c4f5887835953606372c81adf56d1a..585ca541354aa9a9c9c0e25fb310ec77a3796aeb 100644 (file)
--- a/src/xdiff/xemit.c
+++ b/src/xdiff/xemit.c
@@ -65,7 +65,7 @@ xdchange_t *xdl_get_hunk(xdchange_t **xscr, xdemitconf_t const *xecfg)
                        *xscr = xch;
        }
 
-       if (*xscr == NULL)
+       if (!*xscr)
                return NULL;
 
        lxch = *xscr;
@@ -96,7 +96,7 @@ xdchange_t *xdl_get_hunk(xdchange_t **xscr, xdemitconf_t const *xecfg)
 
 
 #if 0
-static long def_ff(const char *rec, long len, char *buf, long sz, void *priv UNUSED)
+static long def_ff(const char *rec, long len, char *buf, long sz)
 {
        if (len > 0 &&
                        (isalpha((unsigned char)*rec) || /* identifier? */
@@ -120,7 +120,7 @@ static long match_func_rec(xdfile_t *xdf, xdemitconf_t const *xecfg, long ri,
        const char *rec;
        long len = xdl_get_rec(xdf, ri, &rec);
        if (!xecfg->find_func)
-               return def_ff(rec, len, buf, sz, xecfg->find_func_priv);
+               return def_ff(rec, len, buf, sz);
        return xecfg->find_func(rec, len, buf, sz, xecfg->find_func_priv);
 }
 #endif

diff --git a/src/xdiff/xhistogram.c b/src/xdiff/xhistogram.c
index 8598a8550d221af6b4afd4527dbeca38ae437733..c0e327514800b058285ccd1246cacff22b08f5f6 100644 (file)
--- a/src/xdiff/xhistogram.c
+++ b/src/xdiff/xhistogram.c
@@ -88,19 +88,14 @@ struct region {
 #define REC(env, s, l) \
        (env->xdf##s.recs[l - 1])
 
-static int cmp_recs(xpparam_t const *xpp,
-       xrecord_t *r1, xrecord_t *r2)
+static int cmp_recs(xrecord_t *r1, xrecord_t *r2)
 {
-       return r1->ha == r2->ha &&
-               xdl_recmatch(r1->ptr, r1->size, r2->ptr, r2->size,
-                           xpp->flags);
-}
+       return r1->ha == r2->ha;
 
-#define CMP_ENV(xpp, env, s1, l1, s2, l2) \
-       (cmp_recs(xpp, REC(env, s1, l1), REC(env, s2, l2)))
+}
 
 #define CMP(i, s1, l1, s2, l2) \
-       (cmp_recs(i->xpp, REC(i->env, s1, l1), REC(i->env, s2, l2)))
+       (cmp_recs(REC(i->env, s1, l1), REC(i->env, s2, l2)))
 
 #define TABLE_HASH(index, side, line) \
        XDL_HASHLONG((REC(index->env, side, line))->ha, index->table_bits)
@@ -256,7 +251,7 @@ static int find_lcs(xpparam_t const *xpp, xdfenv_t *env,
                    int line1, int count1, int line2, int count2)
 {
        int b_ptr;
-       int sz, ret = -1;
+       int ret = -1;
        struct histindex index;
 
        memset(&index, 0, sizeof(index));
@@ -270,23 +265,16 @@ static int find_lcs(xpparam_t const *xpp, xdfenv_t *env,
        index.rcha.head = NULL;
 
        index.table_bits = xdl_hashbits(count1);
-       sz = index.records_size = 1 << index.table_bits;
-       sz *= sizeof(struct record *);
-       if (!(index.records = (struct record **) xdl_malloc(sz)))
+       index.records_size = 1 << index.table_bits;
+       if (!XDL_CALLOC_ARRAY(index.records, index.records_size))
                goto cleanup;
-       memset(index.records, 0, sz);
 
-       sz = index.line_map_size = count1;
-       sz *= sizeof(struct record *);
-       if (!(index.line_map = (struct record **) xdl_malloc(sz)))
+       index.line_map_size = count1;
+       if (!XDL_CALLOC_ARRAY(index.line_map, index.line_map_size))
                goto cleanup;
-       memset(index.line_map, 0, sz);
 
-       sz = index.line_map_size;
-       sz *= sizeof(unsigned int);
-       if (!(index.next_ptrs = (unsigned int *) xdl_malloc(sz)))
+       if (!XDL_CALLOC_ARRAY(index.next_ptrs, index.line_map_size))
                goto cleanup;
-       memset(index.next_ptrs, 0, sz);
 
        /* lines / 4 + 1 comes from xprepare.c:xdl_prepare_ctx() */
        if (xdl_cha_init(&index.rcha, sizeof(struct record), count1 / 4 + 1) < 0)
@@ -374,12 +362,8 @@ out:
        return result;
 }
 
-int xdl_do_histogram_diff(mmfile_t *file1, mmfile_t *file2,
-       xpparam_t const *xpp, xdfenv_t *env)
+int xdl_do_histogram_diff(xpparam_t const *xpp, xdfenv_t *env)
 {
-       if (xdl_prepare_env(file1, file2, xpp, env) < 0)
-               return -1;
-
        return histogram_diff(xpp, env,
                env->xdf1.dstart + 1, env->xdf1.dend - env->xdf1.dstart + 1,
                env->xdf2.dstart + 1, env->xdf2.dend - env->xdf2.dstart + 1);

diff --git a/src/xdiff/xmacros.h b/src/xdiff/xmacros.h
index 2809a28ca960147c285bc5a224ed377a0964663a..8487bb396faa5c6ac984e8295b737b4fbab3f92c 100644 (file)
--- a/src/xdiff/xmacros.h
+++ b/src/xdiff/xmacros.h
@@ -34,7 +34,6 @@
 #define XDL_ADDBITS(v,b)       ((v) + ((v) >> (b)))
 #define XDL_MASKBITS(b)                ((1UL << (b)) - 1)
 #define XDL_HASHLONG(v,b)      (XDL_ADDBITS((unsigned long)(v), b) & XDL_MASKBITS(b))
-#define XDL_PTRFREE(p) do { if (p) { xdl_free(p); (p) = NULL; } } while (0)
 #define XDL_LE32_PUT(p, v) \
 do { \
        unsigned char *__p = (unsigned char *) (p); \
@@ -50,5 +49,23 @@ do { \
                ((unsigned long) __p[2]) << 16 | ((unsigned long) __p[3]) << 24; \
 } while (0)
 
+/* Allocate an array of nr elements, returns NULL on failure */
+#define XDL_ALLOC_ARRAY(p, nr)                         \
+       ((p) = SIZE_MAX / sizeof(*(p)) >= (size_t)(nr)  \
+               ? xdl_malloc((nr) * sizeof(*(p)))       \
+               : NULL)
+
+/* Allocate an array of nr zeroed out elements, returns NULL on failure */
+#define XDL_CALLOC_ARRAY(p, nr)        ((p) = xdl_calloc(nr, sizeof(*(p))))
+
+/*
+ * Ensure array p can accommodate at least nr elements, growing the
+ * array and updating alloc (which is the number of allocated
+ * elements) as necessary. Frees p and returns -1 on failure, returns
+ * 0 on success
+ */
+#define XDL_ALLOC_GROW(p, nr, alloc)   \
+       (-!((nr) <= (alloc) ||          \
+           ((p) = xdl_alloc_grow_helper((p), (nr), &(alloc), sizeof(*(p))))))
 
 #endif /* #if !defined(XMACROS_H) */

diff --git a/src/xdiff/xpatience.c b/src/xdiff/xpatience.c
index f78c897ad8c8fee373a9586d0f1701c8ee8dc764..894a1ba6778df6f3536624e61ffb53b65c42f9cf 100644 (file)
--- a/src/xdiff/xpatience.c
+++ b/src/xdiff/xpatience.c
@@ -69,7 +69,6 @@ struct hashmap {
        } *entries, *first, *last;
        /* were common records found? */
        unsigned long has_matches;
-       mmfile_t *file1, *file2;
        xdfenv_t *env;
        xpparam_t const *xpp;
 };
@@ -139,23 +138,17 @@ static void insert_record(xpparam_t const *xpp, int line, struct hashmap *map,
  *
  * It is assumed that env has been prepared using xdl_prepare().
  */
-static int fill_hashmap(mmfile_t *file1, mmfile_t *file2,
-               xpparam_t const *xpp, xdfenv_t *env,
+static int fill_hashmap(xpparam_t const *xpp, xdfenv_t *env,
                struct hashmap *result,
                int line1, int count1, int line2, int count2)
 {
-       result->file1 = file1;
-       result->file2 = file2;
        result->xpp = xpp;
        result->env = env;
 
        /* We know exactly how large we want the hash map */
        result->alloc = count1 * 2;
-       result->entries = (struct entry *)
-               xdl_malloc(result->alloc * sizeof(struct entry));
-       if (!result->entries)
+       if (!XDL_CALLOC_ARRAY(result->entries, result->alloc))
                return -1;
-       memset(result->entries, 0, result->alloc * sizeof(struct entry));
 
        /* First, fill with entries from the first file */
        while (count1--)
@@ -198,9 +191,9 @@ static int binary_search(struct entry **sequence, int longest,
  * item per sequence length: the sequence with the smallest last
  * element (in terms of line2).
  */
-static struct entry *find_longest_common_sequence(struct hashmap *map)
+static int find_longest_common_sequence(struct hashmap *map, struct entry **res)
 {
-       struct entry **sequence = xdl_malloc(map->nr * sizeof(struct entry *));
+       struct entry **sequence;
        int longest = 0, i;
        struct entry *entry;
 
@@ -211,9 +204,8 @@ static struct entry *find_longest_common_sequence(struct hashmap *map)
         */
        int anchor_i = -1;
 
-       // Added to silence Coverity.
-       if (sequence == NULL)
-               return map->first;
+       if (!XDL_ALLOC_ARRAY(sequence, map->nr))
+               return -1;
 
        for (entry = map->first; entry; entry = entry->next) {
                if (!entry->line2 || entry->line2 == NON_UNIQUE)
@@ -234,8 +226,9 @@ static struct entry *find_longest_common_sequence(struct hashmap *map)
 
        /* No common unique lines were found */
        if (!longest) {
+               *res = NULL;
                xdl_free(sequence);
-               return NULL;
+               return 0;
        }
 
        /* Iterate starting at the last element, adjusting the "next" members */
@@ -245,8 +238,9 @@ static struct entry *find_longest_common_sequence(struct hashmap *map)
                entry->previous->next = entry;
                entry = entry->previous;
        }
+       *res = entry;
        xdl_free(sequence);
-       return entry;
+       return 0;
 }
 
 static int match(struct hashmap *map, int line1, int line2)
@@ -256,8 +250,7 @@ static int match(struct hashmap *map, int line1, int line2)
        return record1->ha == record2->ha;
 }
 
-static int patience_diff(mmfile_t *file1, mmfile_t *file2,
-               xpparam_t const *xpp, xdfenv_t *env,
+static int patience_diff(xpparam_t const *xpp, xdfenv_t *env,
                int line1, int count1, int line2, int count2);
 
 static int walk_common_sequence(struct hashmap *map, struct entry *first,
@@ -288,8 +281,7 @@ static int walk_common_sequence(struct hashmap *map, struct entry *first,
 
                /* Recurse */
                if (next1 > line1 || next2 > line2) {
-                       if (patience_diff(map->file1, map->file2,
-                                       map->xpp, map->env,
+                       if (patience_diff(map->xpp, map->env,
                                        line1, next1 - line1,
                                        line2, next2 - line2))
                                return -1;
@@ -328,8 +320,7 @@ static int fall_back_to_classic_diff(struct hashmap *map,
  *
  * This function assumes that env was prepared with xdl_prepare_env().
  */
-static int patience_diff(mmfile_t *file1, mmfile_t *file2,
-               xpparam_t const *xpp, xdfenv_t *env,
+static int patience_diff(xpparam_t const *xpp, xdfenv_t *env,
                int line1, int count1, int line2, int count2)
 {
        struct hashmap map;
@@ -348,7 +339,7 @@ static int patience_diff(mmfile_t *file1, mmfile_t *file2,
        }
 
        memset(&map, 0, sizeof(map));
-       if (fill_hashmap(file1, file2, xpp, env, &map,
+       if (fill_hashmap(xpp, env, &map,
                        line1, count1, line2, count2))
                return -1;
 
@@ -362,25 +353,21 @@ static int patience_diff(mmfile_t *file1, mmfile_t *file2,
                return 0;
        }
 
-       first = find_longest_common_sequence(&map);
+       result = find_longest_common_sequence(&map, &first);
+       if (result)
+               goto out;
        if (first)
                result = walk_common_sequence(&map, first,
                        line1, count1, line2, count2);
        else
                result = fall_back_to_classic_diff(&map,
                        line1, count1, line2, count2);
-
+ out:
        xdl_free(map.entries);
        return result;
 }
 
-int xdl_do_patience_diff(mmfile_t *file1, mmfile_t *file2,
-               xpparam_t const *xpp, xdfenv_t *env)
+int xdl_do_patience_diff(xpparam_t const *xpp, xdfenv_t *env)
 {
-       if (xdl_prepare_env(file1, file2, xpp, env) < 0)
-               return -1;
-
-       /* environment is cleaned up in xdl_diff() */
-       return patience_diff(file1, file2, xpp, env,
-                       1, env->xdf1.nrec, 1, env->xdf2.nrec);
+       return patience_diff(xpp, env, 1, env->xdf1.nrec, 1, env->xdf2.nrec);
 }

diff --git a/src/xdiff/xprepare.c b/src/xdiff/xprepare.c
index abeb8fb84e6d73086d612b831963a227e35743b8..c84549f6c5089ea08c7bc1daad3ef57dd3fceb77 100644 (file)
--- a/src/xdiff/xprepare.c
+++ b/src/xdiff/xprepare.c
@@ -78,15 +78,14 @@ static int xdl_init_classifier(xdlclassifier_t *cf, long size, long flags) {
 
                return -1;
        }
-       if (!(cf->rchash = (xdlclass_t **) xdl_malloc(cf->hsize * sizeof(xdlclass_t *)))) {
+       if (!XDL_CALLOC_ARRAY(cf->rchash, cf->hsize)) {
 
                xdl_cha_free(&cf->ncha);
                return -1;
        }
-       memset(cf->rchash, 0, cf->hsize * sizeof(xdlclass_t *));
 
        cf->alloc = size;
-       if (!(cf->rcrecs = (xdlclass_t **) xdl_malloc(cf->alloc * sizeof(xdlclass_t *)))) {
+       if (!XDL_ALLOC_ARRAY(cf->rcrecs, cf->alloc)) {
 
                xdl_free(cf->rchash);
                xdl_cha_free(&cf->ncha);
@@ -112,7 +111,6 @@ static int xdl_classify_record(unsigned int pass, xdlclassifier_t *cf, xrecord_t
        long hi;
        char const *line;
        xdlclass_t *rcrec;
-       xdlclass_t **rcrecs;
 
        line = rec->ptr;
        hi = (long) XDL_HASHLONG(rec->ha, cf->hbits);
@@ -128,14 +126,8 @@ static int xdl_classify_record(unsigned int pass, xdlclassifier_t *cf, xrecord_t
                        return -1;
                }
                rcrec->idx = cf->count++;
-               if (cf->count > cf->alloc) {
-                       cf->alloc *= 2;
-                       if (!(rcrecs = (xdlclass_t **) xdl_realloc(cf->rcrecs, cf->alloc * sizeof(xdlclass_t *)))) {
-
+               if (XDL_ALLOC_GROW(cf->rcrecs, cf->count, cf->alloc))
                                return -1;
-                       }
-                       cf->rcrecs = rcrecs;
-               }
                cf->rcrecs[rcrec->idx] = rcrec;
                rcrec->line = line;
                rcrec->size = rec->size;
@@ -164,7 +156,7 @@ static int xdl_prepare_ctx(unsigned int pass, mmfile_t *mf, long narec, xpparam_
        unsigned long hav;
        char const *blk, *cur, *top, *prev;
        xrecord_t *crec;
-       xrecord_t **recs, **rrecs;
+       xrecord_t **recs;
        xrecord_t **rhash;
        unsigned long *ha;
        char *rchg;
@@ -178,51 +170,42 @@ static int xdl_prepare_ctx(unsigned int pass, mmfile_t *mf, long narec, xpparam_
 
        if (xdl_cha_init(&xdf->rcha, sizeof(xrecord_t), narec / 4 + 1) < 0)
                goto abort;
-       if (!(recs = (xrecord_t **) xdl_malloc(narec * sizeof(xrecord_t *))))
+       if (!XDL_ALLOC_ARRAY(recs, narec))
                goto abort;
 
-       if (XDF_DIFF_ALG(xpp->flags) == XDF_HISTOGRAM_DIFF)
-               hbits = hsize = 0;
-       else {
-               hbits = xdl_hashbits((unsigned int) narec);
-               hsize = 1 << hbits;
-               if (!(rhash = (xrecord_t **) xdl_malloc(hsize * sizeof(xrecord_t *))))
-                       goto abort;
-               memset(rhash, 0, hsize * sizeof(xrecord_t *));
-       }
+       hbits = xdl_hashbits((unsigned int) narec);
+       hsize = 1 << hbits;
+       if (!XDL_CALLOC_ARRAY(rhash, hsize))
+               goto abort;
 
        nrec = 0;
-       if ((cur = blk = xdl_mmfile_first(mf, &bsize)) != NULL) {
+       if ((cur = blk = xdl_mmfile_first(mf, &bsize))) {
                for (top = blk + bsize; cur < top; ) {
                        prev = cur;
                        hav = xdl_hash_record(&cur, top, xpp->flags);
-                       if (nrec >= narec) {
-                               narec *= 2;
-                               if (!(rrecs = (xrecord_t **) xdl_realloc(recs, narec * sizeof(xrecord_t *))))
-                                       goto abort;
-                               recs = rrecs;
-                       }
+                       if (XDL_ALLOC_GROW(recs, nrec + 1, narec))
+                               goto abort;
                        if (!(crec = xdl_cha_alloc(&xdf->rcha)))
                                goto abort;
                        crec->ptr = prev;
                        crec->size = (long) (cur - prev);
                        crec->ha = hav;
                        recs[nrec++] = crec;
-
-                       if ((XDF_DIFF_ALG(xpp->flags) != XDF_HISTOGRAM_DIFF) &&
-                           xdl_classify_record(pass, cf, rhash, hbits, crec) < 0)
+                       if (xdl_classify_record(pass, cf, rhash, hbits, crec) < 0)
                                goto abort;
                }
        }
 
-       if (!(rchg = (char *) xdl_malloc((nrec + 2) * sizeof(char))))
+       if (!XDL_CALLOC_ARRAY(rchg, nrec + 2))
                goto abort;
-       memset(rchg, 0, (nrec + 2) * sizeof(char));
 
-       if (!(rindex = (long *) xdl_malloc((nrec + 1) * sizeof(long))))
-               goto abort;
-       if (!(ha = (unsigned long *) xdl_malloc((nrec + 1) * sizeof(unsigned long))))
-               goto abort;
+       if ((XDF_DIFF_ALG(xpp->flags) != XDF_PATIENCE_DIFF) &&
+           (XDF_DIFF_ALG(xpp->flags) != XDF_HISTOGRAM_DIFF)) {
+               if (!XDL_ALLOC_ARRAY(rindex, nrec + 1))
+                       goto abort;
+               if (!XDL_ALLOC_ARRAY(ha, nrec + 1))
+                       goto abort;
+       }
 
        xdf->nrec = nrec;
        xdf->recs = recs;
@@ -279,8 +262,7 @@ int xdl_prepare_env(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
        enl1 = xdl_guess_lines(mf1, sample) + 1;
        enl2 = xdl_guess_lines(mf2, sample) + 1;
 
-       if (XDF_DIFF_ALG(xpp->flags) != XDF_HISTOGRAM_DIFF &&
-           xdl_init_classifier(&cf, enl1 + enl2 + 1, xpp->flags) < 0)
+       if (xdl_init_classifier(&cf, enl1 + enl2 + 1, xpp->flags) < 0)
                return -1;
 
        if (xdl_prepare_ctx(1, mf1, enl1, xpp, &cf, &xe->xdf1) < 0) {
@@ -305,8 +287,7 @@ int xdl_prepare_env(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
                return -1;
        }
 
-       if (XDF_DIFF_ALG(xpp->flags) != XDF_HISTOGRAM_DIFF)
-               xdl_free_classifier(&cf);
+       xdl_free_classifier(&cf);
 
        return 0;
 }
@@ -388,11 +369,8 @@ static int xdl_cleanup_records(xdlclassifier_t *cf, xdfile_t *xdf1, xdfile_t *xd
        xdlclass_t *rcrec;
        char *dis, *dis1, *dis2;
 
-       if (!(dis = (char *) xdl_malloc(xdf1->nrec + xdf2->nrec + 2))) {
-
+       if (!XDL_CALLOC_ARRAY(dis, xdf1->nrec + xdf2->nrec + 2))
                return -1;
-       }
-       memset(dis, 0, xdf1->nrec + xdf2->nrec + 2);
        dis1 = dis;
        dis2 = dis1 + xdf1->nrec + 1;
 

diff --git a/src/xdiff/xutils.c b/src/xdiff/xutils.c
index f13a8545361057363a76b888df6bda6ba4d38d46..a4370e610b8924f1d41fdee295e6473fc7efe3f5 100644 (file)
--- a/src/xdiff/xutils.c
+++ b/src/xdiff/xutils.c
@@ -122,7 +122,7 @@ long xdl_guess_lines(mmfile_t *mf, long sample) {
        long nl = 0, size, tsize = 0;
        char const *data, *cur, *top;
 
-       if ((cur = data = xdl_mmfile_first(mf, &size)) != NULL) {
+       if ((cur = data = xdl_mmfile_first(mf, &size))) {
                for (top = data + size; nl < sample && cur < top; ) {
                        nl++;
                        if (!(cur = memchr(cur, '\n', top - cur)))
@@ -432,3 +432,20 @@ int xdl_fall_back_diff(xdfenv_t *diff_env, xpparam_t const *xpp,
 
        return 0;
 }
+
+void* xdl_alloc_grow_helper(void *p, long nr, long *alloc, size_t size)
+{
+       void *tmp = NULL;
+       size_t n = ((LONG_MAX - 16) / 2 >= *alloc) ? 2 * *alloc + 16 : LONG_MAX;
+       if (nr > (long)n)
+               n = nr;
+       if (SIZE_MAX / size >= n)
+               tmp = xdl_realloc(p, n * size);
+       if (tmp) {
+               *alloc = n;
+       } else {
+               xdl_free(p);
+               *alloc = 0;
+       }
+       return tmp;
+}

diff --git a/src/xdiff/xutils.h b/src/xdiff/xutils.h
index fba7bae03c7855ca90aff3f238321581a91a6676..fd0bba94e8b4d2442ba59d0a4327d2d53e10210a 100644 (file)
--- a/src/xdiff/xutils.h
+++ b/src/xdiff/xutils.h
@@ -42,6 +42,7 @@ int xdl_emit_hunk_hdr(long s1, long c1, long s2, long c2,
 int xdl_fall_back_diff(xdfenv_t *diff_env, xpparam_t const *xpp,
                       int line1, int count1, int line2, int count2);
 
-
+/* Do not call this function, use XDL_ALLOC_GROW instead */
+void* xdl_alloc_grow_helper(void* p, long nr, long* alloc, size_t size);
 
 #endif /* #if !defined(XUTILS_H) */