xdiff: replace {unsigned ,}long with {u,}int64_t

MSVC treats "long" as 4-byte. That could cause overflows since the xdiff
code uses "long" in places where "size_t" or "ssize_t" should be used.
Let's use explicit 8 byte integers to avoid

FWIW git avoids that overflow by limiting diff size to 1GB [1]. After
examining the code, I think the remaining risk (the use of "int") is low
since "int" is only used for return values and hash table size. Although a
wrong hash table size would not affect the correctness of the code, but that
could make the code extremely slow. The next patch will change hash table
size to 8-byte integer so the 1GB limit is unlikely needed.

This patch was done by using `sed`.

[1]: https://github.com/git/git/commit/dcd1742e56ebb944c4ff62346da4548e1e3be67

Differential Revision: https://phab.mercurial-scm.org/D2762

mercurial/thirdparty/xdiff/xdiff.h

@@ -40,28 +40,28 b' extern "C" {'
 
 typedef struct s_mmfile {
 	char *ptr;
-	long size;
+	int64_t size;
 } mmfile_t;
 
 typedef struct s_mmbuffer {
 	char *ptr;
-	long size;
+	int64_t size;
 } mmbuffer_t;
 
 typedef struct s_xpparam {
-	unsigned long flags;
+	uint64_t flags;
 } xpparam_t;
 
 typedef struct s_xdemitcb {
 	void *priv;
 } xdemitcb_t;
 
-typedef int (*xdl_emit_hunk_consume_func_t)(long start_a, long count_a,
-					    long start_b, long count_b,
+typedef int (*xdl_emit_hunk_consume_func_t)(int64_t start_a, int64_t count_a,
+					    int64_t start_b, int64_t count_b,
 					    void *cb_data);
 
 typedef struct s_xdemitconf {
-	unsigned long flags;
+	uint64_t flags;
 	xdl_emit_hunk_consume_func_t hunk_func;
 } xdemitconf_t;
 
@@ -70,8 +70,8 b' typedef struct s_xdemitconf {'
 #define xdl_free(ptr) free(ptr)
 #define xdl_realloc(ptr,x) realloc(ptr,x)
 
-void *xdl_mmfile_first(mmfile_t *mmf, long *size);
-long xdl_mmfile_size(mmfile_t *mmf);
+void *xdl_mmfile_first(mmfile_t *mmf, int64_t *size);
+int64_t xdl_mmfile_size(mmfile_t *mmf);
 
 int xdl_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
 	     xdemitconf_t const *xecfg, xdemitcb_t *ecb);

mercurial/thirdparty/xdiff/xdiffi.c

@@ -37,18 +37,18 b''
 
 
 typedef struct s_xdpsplit {
-	long i1, i2;
+	int64_t i1, i2;
 	int min_lo, min_hi;
 } xdpsplit_t;
 
 
 
 
-static long xdl_split(unsigned long const *ha1, long off1, long lim1,
-		      unsigned long const *ha2, long off2, long lim2,
-		      long *kvdf, long *kvdb, int need_min, xdpsplit_t *spl,
+static int64_t xdl_split(uint64_t const *ha1, int64_t off1, int64_t lim1,
+		      uint64_t const *ha2, int64_t off2, int64_t lim2,
+		      int64_t *kvdf, int64_t *kvdb, int need_min, xdpsplit_t *spl,
 		      xdalgoenv_t *xenv);
-static xdchange_t *xdl_add_change(xdchange_t *xscr, long i1, long i2, long chg1, long chg2);
+static xdchange_t *xdl_add_change(xdchange_t *xscr, int64_t i1, int64_t i2, int64_t chg1, int64_t chg2);
 
 
 
@@ -63,16 +63,16 b' static xdchange_t *xdl_add_change(xdchan'
  * cases using this algorithm is full, so a little bit of heuristic is needed
  * to cut the search and to return a suboptimal point.
  */
-static long xdl_split(unsigned long const *ha1, long off1, long lim1,
-		      unsigned long const *ha2, long off2, long lim2,
-		      long *kvdf, long *kvdb, int need_min, xdpsplit_t *spl,
+static int64_t xdl_split(uint64_t const *ha1, int64_t off1, int64_t lim1,
+		      uint64_t const *ha2, int64_t off2, int64_t lim2,
+		      int64_t *kvdf, int64_t *kvdb, int need_min, xdpsplit_t *spl,
 		      xdalgoenv_t *xenv) {
-	long dmin = off1 - lim2, dmax = lim1 - off2;
-	long fmid = off1 - off2, bmid = lim1 - lim2;
-	long odd = (fmid - bmid) & 1;
-	long fmin = fmid, fmax = fmid;
-	long bmin = bmid, bmax = bmid;
-	long ec, d, i1, i2, prev1, best, dd, v, k;
+	int64_t dmin = off1 - lim2, dmax = lim1 - off2;
+	int64_t fmid = off1 - off2, bmid = lim1 - lim2;
+	int64_t odd = (fmid - bmid) & 1;
+	int64_t fmin = fmid, fmax = fmid;
+	int64_t bmin = bmid, bmax = bmid;
+	int64_t ec, d, i1, i2, prev1, best, dd, v, k;
 
 	/*
 	 * Set initial diagonal values for both forward and backward path.
@@ -221,7 +221,7 b' static long xdl_split(unsigned long cons'
 		 * the furthest reaching path using the (i1 + i2) measure.
 		 */
 		if (ec >= xenv->mxcost) {
-			long fbest, fbest1, bbest, bbest1;
+			int64_t fbest, fbest1, bbest, bbest1;
 
 			fbest = fbest1 = -1;
 			for (d = fmax; d >= fmin; d -= 2) {
@@ -269,10 +269,10 b' static long xdl_split(unsigned long cons'
  * the box splitting function. Note that the real job (marking changed lines)
  * is done in the two boundary reaching checks.
  */
-int xdl_recs_cmp(diffdata_t *dd1, long off1, long lim1,
-		 diffdata_t *dd2, long off2, long lim2,
-		 long *kvdf, long *kvdb, int need_min, xdalgoenv_t *xenv) {
-	unsigned long const *ha1 = dd1->ha, *ha2 = dd2->ha;
+int xdl_recs_cmp(diffdata_t *dd1, int64_t off1, int64_t lim1,
+		 diffdata_t *dd2, int64_t off2, int64_t lim2,
+		 int64_t *kvdf, int64_t *kvdb, int need_min, xdalgoenv_t *xenv) {
+	uint64_t const *ha1 = dd1->ha, *ha2 = dd2->ha;
 
 	/*
 	 * Shrink the box by walking through each diagonal snake (SW and NE).
@@ -286,13 +286,13 b' int xdl_recs_cmp(diffdata_t *dd1, long o'
 	 */
 	if (off1 == lim1) {
 		char *rchg2 = dd2->rchg;
-		long *rindex2 = dd2->rindex;
+		int64_t *rindex2 = dd2->rindex;
 
 		for (; off2 < lim2; off2++)
 			rchg2[rindex2[off2]] = 1;
 	} else if (off2 == lim2) {
 		char *rchg1 = dd1->rchg;
-		long *rindex1 = dd1->rindex;
+		int64_t *rindex1 = dd1->rindex;
 
 		for (; off1 < lim1; off1++)
 			rchg1[rindex1[off1]] = 1;
@@ -327,8 +327,8 b' int xdl_recs_cmp(diffdata_t *dd1, long o'
 
 int xdl_do_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
 		xdfenv_t *xe) {
-	long ndiags;
-	long *kvd, *kvdf, *kvdb;
+	int64_t ndiags;
+	int64_t *kvd, *kvdf, *kvdb;
 	xdalgoenv_t xenv;
 	diffdata_t dd1, dd2;
 
@@ -342,7 +342,7 b' int xdl_do_diff(mmfile_t *mf1, mmfile_t '
 	 * 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 (!(kvd = (int64_t *) xdl_malloc((2 * ndiags + 2) * sizeof(long)))) {
 
 		xdl_free_env(xe);
 		return -1;
@@ -381,7 +381,7 b' int xdl_do_diff(mmfile_t *mf1, mmfile_t '
 }
 
 
-static xdchange_t *xdl_add_change(xdchange_t *xscr, long i1, long i2, long chg1, long chg2) {
+static xdchange_t *xdl_add_change(xdchange_t *xscr, int64_t i1, int64_t i2, int64_t chg1, int64_t chg2) {
 	xdchange_t *xch;
 
 	if (!(xch = (xdchange_t *) xdl_malloc(sizeof(xdchange_t))))
@@ -398,7 +398,7 b' static xdchange_t *xdl_add_change(xdchan'
 }
 
 
-static int recs_match(xrecord_t *rec1, xrecord_t *rec2, long flags)
+static int recs_match(xrecord_t *rec1, xrecord_t *rec2, int64_t flags)
 {
 	return (rec1->ha == rec2->ha &&
 		xdl_recmatch(rec1->ptr, rec1->size,
@@ -421,7 +421,7 b' static int recs_match(xrecord_t *rec1, x'
  */
 static int get_indent(xrecord_t *rec)
 {
-	long i;
+	int64_t i;
 	int ret = 0;
 
 	for (i = 0; i < rec->size; i++) {
@@ -497,10 +497,10 b' struct split_score {'
 /*
  * Fill m with information about a hypothetical split of xdf above line split.
  */
-static void measure_split(const xdfile_t *xdf, long split,
+static void measure_split(const xdfile_t *xdf, int64_t split,
 			  struct split_measurement *m)
 {
-	long i;
+	int64_t i;
 
 	if (split >= xdf->nrec) {
 		m->end_of_file = 1;
@@ -706,13 +706,13 b' struct xdlgroup {'
 	 * The index of the first changed line in the group, or the index of
 	 * the unchanged line above which the (empty) group is located.
 	 */
-	long start;
+	int64_t start;
 
 	/*
 	 * The index of the first unchanged line after the group. For an empty
 	 * group, end is equal to start.
 	 */
-	long end;
+	int64_t end;
 };
 
 /*
@@ -762,7 +762,7 b' static inline int group_previous(xdfile_'
  * 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, int64_t flags)
 {
 	if (g->end < xdf->nrec &&
 	    recs_match(xdf->recs[g->start], xdf->recs[g->end], flags)) {
@@ -783,7 +783,7 b' static int group_slide_down(xdfile_t *xd'
  * 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, int64_t flags)
 {
 	if (g->start > 0 &&
 	    recs_match(xdf->recs[g->start - 1], xdf->recs[g->end - 1], flags)) {
@@ -818,10 +818,10 b' static void xdl_bug(const char *msg)'
  * This also helps in finding joinable change groups and reducing the diff
  * size.
  */
-int xdl_change_compact(xdfile_t *xdf, xdfile_t *xdfo, long flags) {
+int xdl_change_compact(xdfile_t *xdf, xdfile_t *xdfo, int64_t flags) {
 	struct xdlgroup g, go;
-	long earliest_end, end_matching_other;
-	long groupsize;
+	int64_t earliest_end, end_matching_other;
+	int64_t groupsize;
 
 	group_init(xdf, &g);
 	group_init(xdfo, &go);
@@ -906,7 +906,7 b' int xdl_change_compact(xdfile_t *xdf, xd'
 			 * "score" for each position that the group can be shifted
 			 * to. Then we pick the shift with the lowest score.
 			 */
-			long shift, best_shift = -1;
+			int64_t shift, best_shift = -1;
 			struct split_score best_score;
 
 			/*
@@ -975,7 +975,7 b' int xdl_change_compact(xdfile_t *xdf, xd'
 int xdl_build_script(xdfenv_t *xe, xdchange_t **xscr) {
 	xdchange_t *cscr = NULL, *xch;
 	char *rchg1 = xe->xdf1.rchg, *rchg2 = xe->xdf2.rchg;
-	long i1, i2, l1, l2;
+	int64_t i1, i2, l1, l2;
 
 	/*
 	 * Trivial. Collects "groups" of changes and creates an edit script.
@@ -1016,9 +1016,9 b' void xdl_free_script(xdchange_t *xscr) {'
 xdchange_t *xdl_get_hunk(xdchange_t **xscr, xdemitconf_t const *xecfg)
 {
 	xdchange_t *xch, *xchp, *lxch;
-	long max_common = 0;
-	long max_ignorable = 0;
-	unsigned long ignored = 0; /* number of ignored blank lines */
+	int64_t max_common = 0;
+	int64_t max_ignorable = 0;
+	uint64_t ignored = 0; /* number of ignored blank lines */
 
 	/* remove ignorable changes that are too far before other changes */
 	for (xchp = *xscr; xchp && xchp->ignore; xchp = xchp->next) {
@@ -1035,7 +1035,7 b' xdchange_t *xdl_get_hunk(xdchange_t **xs'
 	lxch = *xscr;
 
 	for (xchp = *xscr, xch = xchp->next; xch; xchp = xch, xch = xch->next) {
-		long distance = xch->i1 - (xchp->i1 + xchp->chg1);
+		int64_t distance = xch->i1 - (xchp->i1 + xchp->chg1);
 		if (distance > max_common)
 			break;
 
@@ -1062,14 +1062,14 b' xdchange_t *xdl_get_hunk(xdchange_t **xs'
 static int xdl_call_hunk_func(xdfenv_t *xe, xdchange_t *xscr, xdemitcb_t *ecb,
 			      xdemitconf_t const *xecfg)
 {
-	long p = xe->nprefix, s = xe->nsuffix;
+	int64_t p = xe->nprefix, s = xe->nsuffix;
 	xdchange_t *xch, *xche;
 
 	if (!xecfg->hunk_func)
 		return -1;
 
 	if ((xecfg->flags & XDL_EMIT_BDIFFHUNK) != 0) {
-		long i1 = 0, i2 = 0, n1 = xe->xdf1.nrec, n2 = xe->xdf2.nrec;
+		int64_t i1 = 0, i2 = 0, n1 = xe->xdf1.nrec, n2 = xe->xdf2.nrec;
 		for (xch = xscr; xch; xch = xche->next) {
 			xche = xdl_get_hunk(&xch, xecfg);
 			if (!xch)

mercurial/thirdparty/xdiff/xdiffi.h

@@ -25,33 +25,33 b''
 
 
 typedef struct s_diffdata {
-	long nrec;
-	unsigned long const *ha;
-	long *rindex;
+	int64_t nrec;
+	uint64_t const *ha;
+	int64_t *rindex;
 	char *rchg;
 } diffdata_t;
 
 typedef struct s_xdalgoenv {
-	long mxcost;
-	long snake_cnt;
-	long heur_min;
+	int64_t mxcost;
+	int64_t snake_cnt;
+	int64_t heur_min;
 } xdalgoenv_t;
 
 typedef struct s_xdchange {
 	struct s_xdchange *next;
-	long i1, i2;
-	long chg1, chg2;
+	int64_t i1, i2;
+	int64_t chg1, chg2;
 	int ignore;
 } xdchange_t;
 
 
 
-int xdl_recs_cmp(diffdata_t *dd1, long off1, long lim1,
-		 diffdata_t *dd2, long off2, long lim2,
-		 long *kvdf, long *kvdb, int need_min, xdalgoenv_t *xenv);
+int xdl_recs_cmp(diffdata_t *dd1, int64_t off1, int64_t lim1,
+		 diffdata_t *dd2, int64_t off2, int64_t lim2,
+		 int64_t *kvdf, int64_t *kvdb, int need_min, xdalgoenv_t *xenv);
 int xdl_do_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
 		xdfenv_t *xe);
-int xdl_change_compact(xdfile_t *xdf, xdfile_t *xdfo, long flags);
+int xdl_change_compact(xdfile_t *xdf, xdfile_t *xdfo, int64_t flags);
 int xdl_build_script(xdfenv_t *xe, xdchange_t **xscr);
 void xdl_free_script(xdchange_t *xscr);
 

mercurial/thirdparty/xdiff/xinclude.h

@@ -24,6 +24,7 b''
 #define XINCLUDE_H
 
 #include <ctype.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

mercurial/thirdparty/xdiff/xprepare.c

@@ -31,35 +31,35 b''
 
 typedef struct s_xdlclass {
 	struct s_xdlclass *next;
-	unsigned long ha;
+	uint64_t ha;
 	char const *line;
-	long size;
-	long idx;
-	long len1, len2;
+	int64_t size;
+	int64_t idx;
+	int64_t len1, len2;
 } xdlclass_t;
 
 typedef struct s_xdlclassifier {
 	unsigned int hbits;
-	long hsize;
+	int64_t hsize;
 	xdlclass_t **rchash;
 	chastore_t ncha;
 	xdlclass_t **rcrecs;
-	long alloc;
-	long count;
-	long flags;
+	int64_t alloc;
+	int64_t count;
+	int64_t flags;
 } xdlclassifier_t;
 
 
 
 
-static int xdl_init_classifier(xdlclassifier_t *cf, long size, long flags);
+static int xdl_init_classifier(xdlclassifier_t *cf, int64_t size, int64_t flags);
 static void xdl_free_classifier(xdlclassifier_t *cf);
 static int xdl_classify_record(unsigned int pass, xdlclassifier_t *cf, xrecord_t **rhash,
 			       unsigned int hbits, xrecord_t *rec);
-static int xdl_prepare_ctx(unsigned int pass, mmfile_t *mf, long narec, xpparam_t const *xpp,
+static int xdl_prepare_ctx(unsigned int pass, mmfile_t *mf, int64_t narec, xpparam_t const *xpp,
 			   xdlclassifier_t *cf, xdfile_t *xdf);
 static void xdl_free_ctx(xdfile_t *xdf);
-static int xdl_clean_mmatch(char const *dis, long i, long s, long e);
+static int xdl_clean_mmatch(char const *dis, int64_t i, int64_t s, int64_t e);
 static int xdl_cleanup_records(xdlclassifier_t *cf, xdfile_t *xdf1, xdfile_t *xdf2);
 static int xdl_trim_ends(xdfile_t *xdf1, xdfile_t *xdf2);
 static int xdl_optimize_ctxs(xdlclassifier_t *cf, xdfile_t *xdf1, xdfile_t *xdf2);
@@ -67,7 +67,7 b' static int xdl_optimize_ctxs(xdlclassifi'
 
 
 
-static int xdl_init_classifier(xdlclassifier_t *cf, long size, long flags) {
+static int xdl_init_classifier(xdlclassifier_t *cf, int64_t size, int64_t flags) {
 	cf->flags = flags;
 
 	cf->hbits = xdl_hashbits((unsigned int) size);
@@ -108,7 +108,7 b' static void xdl_free_classifier(xdlclass'
 
 static int xdl_classify_record(unsigned int pass, xdlclassifier_t *cf, xrecord_t **rhash,
 			       unsigned int hbits, xrecord_t *rec) {
-	long hi;
+	int64_t hi;
 	char const *line;
 	xdlclass_t *rcrec;
 	xdlclass_t **rcrecs;
@@ -163,11 +163,11 b' static int xdl_classify_record(unsigned '
  * outweighs the shift change. A diff result with suboptimal shifting is still
  * valid.
  */
-static void xdl_trim_files(mmfile_t *mf1, mmfile_t *mf2, long reserved,
+static void xdl_trim_files(mmfile_t *mf1, mmfile_t *mf2, int64_t reserved,
 		xdfenv_t *xe, mmfile_t *out_mf1, mmfile_t *out_mf2) {
 	mmfile_t msmall, mlarge;
 	/* prefix lines, prefix bytes, suffix lines, suffix bytes */
-	long plines = 0, pbytes = 0, slines = 0, sbytes = 0, i;
+	int64_t plines = 0, pbytes = 0, slines = 0, sbytes = 0, i;
 	/* prefix char pointer for msmall and mlarge */
 	const char *pp1, *pp2;
 	/* suffix char pointer for msmall and mlarge */
@@ -237,18 +237,18 b' static void xdl_trim_files(mmfile_t *mf1'
 }
 
 
-static int xdl_prepare_ctx(unsigned int pass, mmfile_t *mf, long narec, xpparam_t const *xpp,
+static int xdl_prepare_ctx(unsigned int pass, mmfile_t *mf, int64_t narec, xpparam_t const *xpp,
 			   xdlclassifier_t *cf, xdfile_t *xdf) {
 	unsigned int hbits;
-	long nrec, hsize, bsize;
-	unsigned long hav;
+	int64_t nrec, hsize, bsize;
+	uint64_t hav;
 	char const *blk, *cur, *top, *prev;
 	xrecord_t *crec;
 	xrecord_t **recs, **rrecs;
 	xrecord_t **rhash;
-	unsigned long *ha;
+	uint64_t *ha;
 	char *rchg;
-	long *rindex;
+	int64_t *rindex;
 
 	ha = NULL;
 	rindex = NULL;
@@ -296,9 +296,9 b' static int xdl_prepare_ctx(unsigned int '
 		goto abort;
 	memset(rchg, 0, (nrec + 2) * sizeof(char));
 
-	if (!(rindex = (long *) xdl_malloc((nrec + 1) * sizeof(long))))
+	if (!(rindex = (int64_t *) xdl_malloc((nrec + 1) * sizeof(long))))
 		goto abort;
-	if (!(ha = (unsigned long *) xdl_malloc((nrec + 1) * sizeof(unsigned long))))
+	if (!(ha = (uint64_t *) xdl_malloc((nrec + 1) * sizeof(unsigned long))))
 		goto abort;
 
 	xdf->nrec = nrec;
@@ -340,7 +340,7 b' static void xdl_free_ctx(xdfile_t *xdf) '
 
 int xdl_prepare_env(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
 		    xdfenv_t *xe) {
-	long enl1, enl2, sample;
+	int64_t enl1, enl2, sample;
 	mmfile_t tmf1, tmf2;
 	xdlclassifier_t cf;
 
@@ -388,8 +388,8 b' void xdl_free_env(xdfenv_t *xe) {'
 }
 
 
-static int xdl_clean_mmatch(char const *dis, long i, long s, long e) {
-	long r, rdis0, rpdis0, rdis1, rpdis1;
+static int xdl_clean_mmatch(char const *dis, int64_t i, int64_t s, int64_t e) {
+	int64_t r, rdis0, rpdis0, rdis1, rpdis1;
 
 	/*
 	 * Limits the window the is examined during the similar-lines
@@ -452,7 +452,7 b' static int xdl_clean_mmatch(char const *'
  * might be potentially discarded if they happear in a run of discardable.
  */
 static int xdl_cleanup_records(xdlclassifier_t *cf, xdfile_t *xdf1, xdfile_t *xdf2) {
-	long i, nm, nreff, mlim;
+	int64_t i, nm, nreff, mlim;
 	xrecord_t **recs;
 	xdlclass_t *rcrec;
 	char *dis, *dis1, *dis2;
@@ -515,7 +515,7 b' static int xdl_cleanup_records(xdlclassi'
  * Early trim initial and terminal matching records.
  */
 static int xdl_trim_ends(xdfile_t *xdf1, xdfile_t *xdf2) {
-	long i, lim;
+	int64_t i, lim;
 	xrecord_t **recs1, **recs2;
 
 	recs1 = xdf1->recs;

mercurial/thirdparty/xdiff/xtypes.h

@@ -27,22 +27,22 b''
 
 typedef struct s_chanode {
 	struct s_chanode *next;
-	long icurr;
+	int64_t icurr;
 } chanode_t;
 
 typedef struct s_chastore {
 	chanode_t *head, *tail;
-	long isize, nsize;
+	int64_t isize, nsize;
 	chanode_t *ancur;
 	chanode_t *sncur;
-	long scurr;
+	int64_t scurr;
 } chastore_t;
 
 typedef struct s_xrecord {
 	struct s_xrecord *next;
 	char const *ptr;
-	long size;
-	unsigned long ha;
+	int64_t size;
+	uint64_t ha;
 } xrecord_t;
 
 typedef struct s_xdfile {
@@ -50,7 +50,7 b' typedef struct s_xdfile {'
 	chastore_t rcha;
 
 	/* number of records (lines) */
-	long nrec;
+	int64_t nrec;
 
 	/* hash table size
 	 * the maximum hash value in the table is (1 << hbits) */
@@ -64,7 +64,7 b' typedef struct s_xdfile {'
 	 * [recs[i] for i in range(0, dstart)] are common prefix.
 	 * [recs[i] for i in range(dstart, dend + 1 - dstart)] are interesting
 	 * lines */
-	long dstart, dend;
+	int64_t dstart, dend;
 
 	/* pointer to records (lines) */
 	xrecord_t **recs;
@@ -82,14 +82,14 b' typedef struct s_xdfile {'
 	 * rindex[0] is likely dstart, if not removed up by rule 2.
 	 * rindex[nreff - 1] is likely dend, if not removed by rule 2.
 	 */
-	long *rindex;
+	int64_t *rindex;
 
 	/* rindex size */
-	long nreff;
+	int64_t nreff;
 
 	/* cleaned-up record index => hash value
 	 * ha[i] = recs[rindex[i]]->ha */
-	unsigned long *ha;
+	uint64_t *ha;
 } xdfile_t;
 
 typedef struct s_xdfenv {
@@ -97,7 +97,7 b' typedef struct s_xdfenv {'
 
 	/* number of lines for common prefix and suffix that are removed
 	 * from xdf1 and xdf2 as a preprocessing step */
-	long nprefix, nsuffix;
+	int64_t nprefix, nsuffix;
 } xdfenv_t;
 
 

mercurial/thirdparty/xdiff/xutils.c

@@ -27,8 +27,8 b''
 
 
 
-long xdl_bogosqrt(long n) {
-	long i;
+int64_t xdl_bogosqrt(int64_t n) {
+	int64_t i;
 
 	/*
 	 * Classical integer square root approximation using shifts.
@@ -40,20 +40,20 b' long xdl_bogosqrt(long n) {'
 }
 
 
-void *xdl_mmfile_first(mmfile_t *mmf, long *size)
+void *xdl_mmfile_first(mmfile_t *mmf, int64_t *size)
 {
 	*size = mmf->size;
 	return mmf->ptr;
 }
 
 
-long xdl_mmfile_size(mmfile_t *mmf)
+int64_t xdl_mmfile_size(mmfile_t *mmf)
 {
 	return mmf->size;
 }
 
 
-int xdl_cha_init(chastore_t *cha, long isize, long icount) {
+int xdl_cha_init(chastore_t *cha, int64_t isize, int64_t icount) {
 
 	cha->head = cha->tail = NULL;
 	cha->isize = isize;
@@ -100,8 +100,8 b' void *xdl_cha_alloc(chastore_t *cha) {'
 	return data;
 }
 
-long xdl_guess_lines(mmfile_t *mf, long sample) {
-	long nl = 0, size, tsize = 0;
+int64_t xdl_guess_lines(mmfile_t *mf, int64_t sample) {
+	int64_t nl = 0, size, tsize = 0;
 	char const *data, *cur, *top;
 
 	if ((cur = data = xdl_mmfile_first(mf, &size)) != NULL) {
@@ -121,15 +121,15 b' long xdl_guess_lines(mmfile_t *mf, long '
 	return nl + 1;
 }
 
-int xdl_recmatch(const char *l1, long s1, const char *l2, long s2, long flags)
+int xdl_recmatch(const char *l1, int64_t s1, const char *l2, int64_t s2, int64_t flags)
 {
 	if (s1 == s2 && !memcmp(l1, l2, s1))
 		return 1;
 	return 0;
 }
 
-unsigned long xdl_hash_record(char const **data, char const *top, long flags) {
-	unsigned long ha = 5381;
+uint64_t xdl_hash_record(char const **data, char const *top, int64_t flags) {
+	uint64_t ha = 5381;
 	char const *ptr = *data;
 
 	for (; ptr < top && *ptr != '\n'; ptr++) {

mercurial/thirdparty/xdiff/xutils.h

@@ -25,13 +25,13 b''
 
 
 
-long xdl_bogosqrt(long n);
-int xdl_cha_init(chastore_t *cha, long isize, long icount);
+int64_t xdl_bogosqrt(int64_t n);
+int xdl_cha_init(chastore_t *cha, int64_t isize, int64_t icount);
 void xdl_cha_free(chastore_t *cha);
 void *xdl_cha_alloc(chastore_t *cha);
-long xdl_guess_lines(mmfile_t *mf, long sample);
-int xdl_recmatch(const char *l1, long s1, const char *l2, long s2, long flags);
-unsigned long xdl_hash_record(char const **data, char const *top, long flags);
+int64_t xdl_guess_lines(mmfile_t *mf, int64_t sample);
+int xdl_recmatch(const char *l1, int64_t s1, const char *l2, int64_t s2, int64_t flags);
+uint64_t xdl_hash_record(char const **data, char const *top, int64_t flags);
 unsigned int xdl_hashbits(unsigned int size);