xdiff: remove xemit related logic

xemit handles "diff formatting and output" with options like context lines,
whether show function names, etc. That is handled more cleanly at a higher
level in hg.

Removing context line parameters would also make the trimming logic (D2686)
cleaner and more confident. See [1].

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

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

mercurial/cext/bdiff.c

@@ -1,350 +1,345 b''
 /*
  bdiff.c - efficient binary diff extension for Mercurial
 
  Copyright 2005, 2006 Matt Mackall <[e-mail]>
 
  This software may be used and distributed according to the terms of
  the GNU General Public License, incorporated herein by reference.
 
  Based roughly on Python difflib
 */
 
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "bdiff.h"
 #include "bitmanipulation.h"
 #include "thirdparty/xdiff/xdiff.h"
 #include "util.h"
 
 static PyObject *blocks(PyObject *self, PyObject *args)
 {
 	PyObject *sa, *sb, *rl = NULL, *m;
 	struct bdiff_line *a, *b;
 	struct bdiff_hunk l, *h;
 	int an, bn, count, pos = 0;
 
 	l.next = NULL;
 
 	if (!PyArg_ParseTuple(args, "SS:bdiff", &sa, &sb))
 		return NULL;
 
 	an = bdiff_splitlines(PyBytes_AsString(sa), PyBytes_Size(sa), &a);
 	bn = bdiff_splitlines(PyBytes_AsString(sb), PyBytes_Size(sb), &b);
 
 	if (!a || !b)
 		goto nomem;
 
 	count = bdiff_diff(a, an, b, bn, &l);
 	if (count < 0)
 		goto nomem;
 
 	rl = PyList_New(count);
 	if (!rl)
 		goto nomem;
 
 	for (h = l.next; h; h = h->next) {
 		m = Py_BuildValue("iiii", h->a1, h->a2, h->b1, h->b2);
 		PyList_SetItem(rl, pos, m);
 		pos++;
 	}
 
 nomem:
 	free(a);
 	free(b);
 	bdiff_freehunks(l.next);
 	return rl ? rl : PyErr_NoMemory();
 }
 
 static PyObject *bdiff(PyObject *self, PyObject *args)
 {
 	Py_buffer ba, bb;
 	char *rb, *ia, *ib;
 	PyObject *result = NULL;
 	struct bdiff_line *al = NULL, *bl = NULL;
 	struct bdiff_hunk l, *h;
 	int an, bn, count;
 	Py_ssize_t len = 0, la, lb, li = 0, lcommon = 0, lmax;
 	PyThreadState *_save = NULL;
 
 	l.next = NULL;
 
 	if (!PyArg_ParseTuple(args, PY23("s*s*:bdiff", "y*y*:bdiff"), &ba, &bb))
 		return NULL;
 
 	if (!PyBuffer_IsContiguous(&ba, 'C') || ba.ndim > 1) {
 		PyErr_SetString(PyExc_ValueError, "bdiff input not contiguous");
 		goto cleanup;
 	}
 
 	if (!PyBuffer_IsContiguous(&bb, 'C') || bb.ndim > 1) {
 		PyErr_SetString(PyExc_ValueError, "bdiff input not contiguous");
 		goto cleanup;
 	}
 
 	la = ba.len;
 	lb = bb.len;
 
 	if (la > UINT_MAX || lb > UINT_MAX) {
 		PyErr_SetString(PyExc_ValueError, "bdiff inputs too large");
 		goto cleanup;
 	}
 
 	_save = PyEval_SaveThread();
 
 	lmax = la > lb ? lb : la;
 	for (ia = ba.buf, ib = bb.buf; li < lmax && *ia == *ib;
 	     ++li, ++ia, ++ib) {
 		if (*ia == '\n')
 			lcommon = li + 1;
 	}
 	/* we can almost add: if (li == lmax) lcommon = li; */
 
 	an = bdiff_splitlines((char *)ba.buf + lcommon, la - lcommon, &al);
 	bn = bdiff_splitlines((char *)bb.buf + lcommon, lb - lcommon, &bl);
 	if (!al || !bl) {
 		PyErr_NoMemory();
 		goto cleanup;
 	}
 
 	count = bdiff_diff(al, an, bl, bn, &l);
 	if (count < 0) {
 		PyErr_NoMemory();
 		goto cleanup;
 	}
 
 	/* calculate length of output */
 	la = lb = 0;
 	for (h = l.next; h; h = h->next) {
 		if (h->a1 != la || h->b1 != lb)
 			len += 12 + bl[h->b1].l - bl[lb].l;
 		la = h->a2;
 		lb = h->b2;
 	}
 	PyEval_RestoreThread(_save);
 	_save = NULL;
 
 	result = PyBytes_FromStringAndSize(NULL, len);
 
 	if (!result)
 		goto cleanup;
 
 	/* build binary patch */
 	rb = PyBytes_AsString(result);
 	la = lb = 0;
 
 	for (h = l.next; h; h = h->next) {
 		if (h->a1 != la || h->b1 != lb) {
 			len = bl[h->b1].l - bl[lb].l;
 			putbe32((uint32_t)(al[la].l + lcommon - al->l), rb);
 			putbe32((uint32_t)(al[h->a1].l + lcommon - al->l),
 			        rb + 4);
 			putbe32((uint32_t)len, rb + 8);
 			memcpy(rb + 12, bl[lb].l, len);
 			rb += 12 + len;
 		}
 		la = h->a2;
 		lb = h->b2;
 	}
 
 cleanup:
 	if (_save)
 		PyEval_RestoreThread(_save);
 	PyBuffer_Release(&ba);
 	PyBuffer_Release(&bb);
 	if (al) {
 		free(al);
 	}
 	if (bl) {
 		free(bl);
 	}
 	if (l.next) {
 		bdiff_freehunks(l.next);
 	}
 	return result;
 }
 
 /*
  * If allws != 0, remove all whitespace (' ', \t and \r). Otherwise,
  * reduce whitespace sequences to a single space and trim remaining whitespace
  * from end of lines.
  */
 static PyObject *fixws(PyObject *self, PyObject *args)
 {
 	PyObject *s, *result = NULL;
 	char allws, c;
 	const char *r;
 	Py_ssize_t i, rlen, wlen = 0;
 	char *w;
 
 	if (!PyArg_ParseTuple(args, "Sb:fixws", &s, &allws))
 		return NULL;
 	r = PyBytes_AsString(s);
 	rlen = PyBytes_Size(s);
 
 	w = (char *)PyMem_Malloc(rlen ? rlen : 1);
 	if (!w)
 		goto nomem;
 
 	for (i = 0; i != rlen; i++) {
 		c = r[i];
 		if (c == ' ' || c == '\t' || c == '\r') {
 			if (!allws && (wlen == 0 || w[wlen - 1] != ' '))
 				w[wlen++] = ' ';
 		} else if (c == '\n' && !allws && wlen > 0 &&
 		           w[wlen - 1] == ' ') {
 			w[wlen - 1] = '\n';
 		} else {
 			w[wlen++] = c;
 		}
 	}
 
 	result = PyBytes_FromStringAndSize(w, wlen);
 
 nomem:
 	PyMem_Free(w);
 	return result ? result : PyErr_NoMemory();
 }
 
 static bool sliceintolist(PyObject *list, Py_ssize_t destidx,
                           const char *source, Py_ssize_t len)
 {
 	PyObject *sliced = PyBytes_FromStringAndSize(source, len);
 	if (sliced == NULL)
 		return false;
 	PyList_SET_ITEM(list, destidx, sliced);
 	return true;
 }
 
 static PyObject *splitnewlines(PyObject *self, PyObject *args)
 {
 	const char *text;
 	Py_ssize_t nelts = 0, size, i, start = 0;
 	PyObject *result = NULL;
 
 	if (!PyArg_ParseTuple(args, PY23("s#", "y#"), &text, &size)) {
 		goto abort;
 	}
 	if (!size) {
 		return PyList_New(0);
 	}
 	/* This loops to size-1 because if the last byte is a newline,
 	 * we don't want to perform a split there. */
 	for (i = 0; i < size - 1; ++i) {
 		if (text[i] == '\n') {
 			++nelts;
 		}
 	}
 	if ((result = PyList_New(nelts + 1)) == NULL)
 		goto abort;
 	nelts = 0;
 	for (i = 0; i < size - 1; ++i) {
 		if (text[i] == '\n') {
 			if (!sliceintolist(result, nelts++, text + start,
 			                   i - start + 1))
 				goto abort;
 			start = i + 1;
 		}
 	}
 	if (!sliceintolist(result, nelts++, text + start, size - start))
 		goto abort;
 	return result;
 abort:
 	Py_XDECREF(result);
 	return NULL;
 }
 
 static int hunk_consumer(long a1, long a2, long b1, long b2, void *priv)
 {
 	PyObject *rl = (PyObject *)priv;
 	PyObject *m = Py_BuildValue("llll", a1, a2, b1, b2);
 	if (!m)
 		return -1;
 	if (PyList_Append(rl, m) != 0) {
 		Py_DECREF(m);
 		return -1;
 	}
 	return 0;
 }
 
 static PyObject *xdiffblocks(PyObject *self, PyObject *args)
 {
 	Py_ssize_t la, lb;
 	mmfile_t a, b;
 	PyObject *rl;
 
 	xpparam_t xpp = {
 	    XDF_INDENT_HEURISTIC, /* flags */
 	};
 	xdemitconf_t xecfg = {
-	    0,                  /* ctxlen */
-	    0,                  /* interhunkctxlen */
 	    XDL_EMIT_BDIFFHUNK, /* flags */
-	    NULL,               /* find_func */
-	    NULL,               /* find_func_priv */
 	    hunk_consumer,      /* hunk_consume_func */
 	};
 	xdemitcb_t ecb = {
 	    NULL, /* priv */
-	    NULL, /* outf */
 	};
 
 	if (!PyArg_ParseTuple(args, PY23("s#s#", "y#y#"), &a.ptr, &la, &b.ptr,
 	                      &lb))
 		return NULL;
 
 	a.size = la;
 	b.size = lb;
 
 	rl = PyList_New(0);
 	if (!rl)
 		return PyErr_NoMemory();
 
 	ecb.priv = rl;
 
 	if (xdl_diff(&a, &b, &xpp, &xecfg, &ecb) != 0) {
 		Py_DECREF(rl);
 		return PyErr_NoMemory();
 	}
 
 	return rl;
 }
 
 static char mdiff_doc[] = "Efficient binary diff.";
 
 static PyMethodDef methods[] = {
     {"bdiff", bdiff, METH_VARARGS, "calculate a binary diff\n"},
     {"blocks", blocks, METH_VARARGS, "find a list of matching lines\n"},
     {"fixws", fixws, METH_VARARGS, "normalize diff whitespaces\n"},
     {"splitnewlines", splitnewlines, METH_VARARGS,
      "like str.splitlines, but only split on newlines\n"},
     {"xdiffblocks", xdiffblocks, METH_VARARGS,
      "find a list of matching lines using xdiff algorithm\n"},
     {NULL, NULL},
 };
 
 static const int version = 3;
 
 #ifdef IS_PY3K
 static struct PyModuleDef bdiff_module = {
     PyModuleDef_HEAD_INIT, "bdiff", mdiff_doc, -1, methods,
 };
 
 PyMODINIT_FUNC PyInit_bdiff(void)
 {
 	PyObject *m;
 	m = PyModule_Create(&bdiff_module);
 	PyModule_AddIntConstant(m, "version", version);
 	return m;
 }
 #else
 PyMODINIT_FUNC initbdiff(void)
 {
 	PyObject *m;
 	m = Py_InitModule3("bdiff", methods, mdiff_doc);
 	PyModule_AddIntConstant(m, "version", version);
 }
 #endif

mercurial/thirdparty/xdiff/xdiff.h

@@ -1,123 +1,113 b''
 /*
  *  LibXDiff by Davide Libenzi ( File Differential Library )
  *  Copyright (C) 2003  Davide Libenzi
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
  *  version 2.1 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this library; if not, see
  *  <http://www.gnu.org/licenses/>.
  *
  *  Davide Libenzi <[e-mail]>
  *
  */
 
 #if !defined(XDIFF_H)
 #define XDIFF_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* #ifdef __cplusplus */
 
 #include <stddef.h> /* size_t */
 
 /* xpparm_t.flags */
 #define XDF_NEED_MINIMAL (1 << 0)
 
 #define XDF_INDENT_HEURISTIC (1 << 23)
 
-/* xdemitconf_t.flags */
-#define XDL_EMIT_FUNCNAMES (1 << 0)
-#define XDL_EMIT_FUNCCONTEXT (1 << 2)
 /* emit bdiff-style "matched" (a1, a2, b1, b2) hunks instead of "different"
  * (a1, a2 - a1, b1, b2 - b1) hunks */
 #define XDL_EMIT_BDIFFHUNK (1 << 4)
 
 /* merge simplification levels */
 #define XDL_MERGE_MINIMAL 0
 #define XDL_MERGE_EAGER 1
 #define XDL_MERGE_ZEALOUS 2
 #define XDL_MERGE_ZEALOUS_ALNUM 3
 
 /* merge favor modes */
 #define XDL_MERGE_FAVOR_OURS 1
 #define XDL_MERGE_FAVOR_THEIRS 2
 #define XDL_MERGE_FAVOR_UNION 3
 
 /* merge output styles */
 #define XDL_MERGE_DIFF3 1
 
 typedef struct s_mmfile {
 	char *ptr;
 	long size;
 } mmfile_t;
 
 typedef struct s_mmbuffer {
 	char *ptr;
 	long size;
 } mmbuffer_t;
 
 typedef struct s_xpparam {
 	unsigned long flags;
 } xpparam_t;
 
 typedef struct s_xdemitcb {
 	void *priv;
-	int (*outf)(void *, mmbuffer_t *, int);
 } xdemitcb_t;
 
-typedef long (*find_func_t)(const char *line, long line_len, char *buffer, long buffer_size, void *priv);
-
 typedef int (*xdl_emit_hunk_consume_func_t)(long start_a, long count_a,
 					    long start_b, long count_b,
 					    void *cb_data);
 
 typedef struct s_xdemitconf {
-	long ctxlen;
-	long interhunkctxlen;
 	unsigned long flags;
-	find_func_t find_func;
-	void *find_func_priv;
 	xdl_emit_hunk_consume_func_t hunk_func;
 } xdemitconf_t;
 
 
 #define xdl_malloc(x) malloc(x)
 #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);
 
 int xdl_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
 	     xdemitconf_t const *xecfg, xdemitcb_t *ecb);
 
 typedef struct s_xmparam {
 	xpparam_t xpp;
 	int marker_size;
 	int level;
 	int favor;
 	int style;
 	const char *ancestor;	/* label for orig */
 	const char *file1;	/* label for mf1 */
 	const char *file2;	/* label for mf2 */
 } xmparam_t;
 
 #define DEFAULT_CONFLICT_MARKER_SIZE 7
 
 int xdl_merge(mmfile_t *orig, mmfile_t *mf1, mmfile_t *mf2,
 		xmparam_t const *xmp, mmbuffer_t *result);
 
 #ifdef __cplusplus
 }
 #endif /* #ifdef __cplusplus */
 
 #endif /* #if !defined(XDIFF_H) */

mercurial/thirdparty/xdiff/xdiffi.c

@@ -1,1071 +1,1126 b''
 /*
  *  LibXDiff by Davide Libenzi ( File Differential Library )
  *  Copyright (C) 2003	Davide Libenzi
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
  *  version 2.1 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this library; if not, see
  *  <http://www.gnu.org/licenses/>.
  *
  *  Davide Libenzi <[e-mail]>
  *
  */
 
 #include "xinclude.h"
 
 
 
 #define XDL_MAX_COST_MIN 256
 #define XDL_HEUR_MIN_COST 256
 #define XDL_LINE_MAX (long)((1UL << (CHAR_BIT * sizeof(long) - 1)) - 1)
 #define XDL_SNAKE_CNT 20
 #define XDL_K_HEUR 4
 
 /* VC 2008 doesn't know about the inline keyword. */
 #if defined(_MSC_VER)
 #define inline __forceinline
 #endif
 
 
 typedef struct s_xdpsplit {
 	long 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,
 		      xdalgoenv_t *xenv);
 static xdchange_t *xdl_add_change(xdchange_t *xscr, long i1, long i2, long chg1, long chg2);
 
 
 
 
 
 /*
  * See "An O(ND) Difference Algorithm and its Variations", by Eugene Myers.
  * Basically considers a "box" (off1, off2, lim1, lim2) and scan from both
  * the forward diagonal starting from (off1, off2) and the backward diagonal
  * starting from (lim1, lim2). If the K values on the same diagonal crosses
  * returns the furthest point of reach. We might end up having to expensive
  * 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,
 		      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;
 
 	/*
 	 * Set initial diagonal values for both forward and backward path.
 	 */
 	kvdf[fmid] = off1;
 	kvdb[bmid] = lim1;
 
 	for (ec = 1;; ec++) {
 		int got_snake = 0;
 
 		/*
 		 * We need to extent the diagonal "domain" by one. If the next
 		 * values exits the box boundaries we need to change it in the
 		 * opposite direction because (max - min) must be a power of two.
 		 * Also we initialize the external K value to -1 so that we can
 		 * avoid extra conditions check inside the core loop.
 		 */
 		if (fmin > dmin)
 			kvdf[--fmin - 1] = -1;
 		else
 			++fmin;
 		if (fmax < dmax)
 			kvdf[++fmax + 1] = -1;
 		else
 			--fmax;
 
 		for (d = fmax; d >= fmin; d -= 2) {
 			if (kvdf[d - 1] >= kvdf[d + 1])
 				i1 = kvdf[d - 1] + 1;
 			else
 				i1 = kvdf[d + 1];
 			prev1 = i1;
 			i2 = i1 - d;
 			for (; i1 < lim1 && i2 < lim2 && ha1[i1] == ha2[i2]; i1++, i2++);
 			if (i1 - prev1 > xenv->snake_cnt)
 				got_snake = 1;
 			kvdf[d] = i1;
 			if (odd && bmin <= d && d <= bmax && kvdb[d] <= i1) {
 				spl->i1 = i1;
 				spl->i2 = i2;
 				spl->min_lo = spl->min_hi = 1;
 				return ec;
 			}
 		}
 
 		/*
 		 * We need to extent the diagonal "domain" by one. If the next
 		 * values exits the box boundaries we need to change it in the
 		 * opposite direction because (max - min) must be a power of two.
 		 * Also we initialize the external K value to -1 so that we can
 		 * avoid extra conditions check inside the core loop.
 		 */
 		if (bmin > dmin)
 			kvdb[--bmin - 1] = XDL_LINE_MAX;
 		else
 			++bmin;
 		if (bmax < dmax)
 			kvdb[++bmax + 1] = XDL_LINE_MAX;
 		else
 			--bmax;
 
 		for (d = bmax; d >= bmin; d -= 2) {
 			if (kvdb[d - 1] < kvdb[d + 1])
 				i1 = kvdb[d - 1];
 			else
 				i1 = kvdb[d + 1] - 1;
 			prev1 = i1;
 			i2 = i1 - d;
 			for (; i1 > off1 && i2 > off2 && ha1[i1 - 1] == ha2[i2 - 1]; i1--, i2--);
 			if (prev1 - i1 > xenv->snake_cnt)
 				got_snake = 1;
 			kvdb[d] = i1;
 			if (!odd && fmin <= d && d <= fmax && i1 <= kvdf[d]) {
 				spl->i1 = i1;
 				spl->i2 = i2;
 				spl->min_lo = spl->min_hi = 1;
 				return ec;
 			}
 		}
 
 		if (need_min)
 			continue;
 
 		/*
 		 * If the edit cost is above the heuristic trigger and if
 		 * we got a good snake, we sample current diagonals to see
 		 * if some of the, have reached an "interesting" path. Our
 		 * measure is a function of the distance from the diagonal
 		 * corner (i1 + i2) penalized with the distance from the
 		 * mid diagonal itself. If this value is above the current
 		 * edit cost times a magic factor (XDL_K_HEUR) we consider
 		 * it interesting.
 		 */
 		if (got_snake && ec > xenv->heur_min) {
 			for (best = 0, d = fmax; d >= fmin; d -= 2) {
 				dd = d > fmid ? d - fmid: fmid - d;
 				i1 = kvdf[d];
 				i2 = i1 - d;
 				v = (i1 - off1) + (i2 - off2) - dd;
 
 				if (v > XDL_K_HEUR * ec && v > best &&
 				    off1 + xenv->snake_cnt <= i1 && i1 < lim1 &&
 				    off2 + xenv->snake_cnt <= i2 && i2 < lim2) {
 					for (k = 1; ha1[i1 - k] == ha2[i2 - k]; k++)
 						if (k == xenv->snake_cnt) {
 							best = v;
 							spl->i1 = i1;
 							spl->i2 = i2;
 							break;
 						}
 				}
 			}
 			if (best > 0) {
 				spl->min_lo = 1;
 				spl->min_hi = 0;
 				return ec;
 			}
 
 			for (best = 0, d = bmax; d >= bmin; d -= 2) {
 				dd = d > bmid ? d - bmid: bmid - d;
 				i1 = kvdb[d];
 				i2 = i1 - d;
 				v = (lim1 - i1) + (lim2 - i2) - dd;
 
 				if (v > XDL_K_HEUR * ec && v > best &&
 				    off1 < i1 && i1 <= lim1 - xenv->snake_cnt &&
 				    off2 < i2 && i2 <= lim2 - xenv->snake_cnt) {
 					for (k = 0; ha1[i1 + k] == ha2[i2 + k]; k++)
 						if (k == xenv->snake_cnt - 1) {
 							best = v;
 							spl->i1 = i1;
 							spl->i2 = i2;
 							break;
 						}
 				}
 			}
 			if (best > 0) {
 				spl->min_lo = 0;
 				spl->min_hi = 1;
 				return ec;
 			}
 		}
 
 		/*
 		 * Enough is enough. We spent too much time here and now we collect
 		 * the furthest reaching path using the (i1 + i2) measure.
 		 */
 		if (ec >= xenv->mxcost) {
 			long fbest, fbest1, bbest, bbest1;
 
 			fbest = fbest1 = -1;
 			for (d = fmax; d >= fmin; d -= 2) {
 				i1 = XDL_MIN(kvdf[d], lim1);
 				i2 = i1 - d;
 				if (lim2 < i2)
 					i1 = lim2 + d, i2 = lim2;
 				if (fbest < i1 + i2) {
 					fbest = i1 + i2;
 					fbest1 = i1;
 				}
 			}
 
 			bbest = bbest1 = XDL_LINE_MAX;
 			for (d = bmax; d >= bmin; d -= 2) {
 				i1 = XDL_MAX(off1, kvdb[d]);
 				i2 = i1 - d;
 				if (i2 < off2)
 					i1 = off2 + d, i2 = off2;
 				if (i1 + i2 < bbest) {
 					bbest = i1 + i2;
 					bbest1 = i1;
 				}
 			}
 
 			if ((lim1 + lim2) - bbest < fbest - (off1 + off2)) {
 				spl->i1 = fbest1;
 				spl->i2 = fbest - fbest1;
 				spl->min_lo = 1;
 				spl->min_hi = 0;
 			} else {
 				spl->i1 = bbest1;
 				spl->i2 = bbest - bbest1;
 				spl->min_lo = 0;
 				spl->min_hi = 1;
 			}
 			return ec;
 		}
 	}
 }
 
 
 /*
  * Rule: "Divide et Impera". Recursively split the box in sub-boxes by calling
  * 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;
 
 	/*
 	 * Shrink the box by walking through each diagonal snake (SW and NE).
 	 */
 	for (; off1 < lim1 && off2 < lim2 && ha1[off1] == ha2[off2]; off1++, off2++);
 	for (; off1 < lim1 && off2 < lim2 && ha1[lim1 - 1] == ha2[lim2 - 1]; lim1--, lim2--);
 
 	/*
 	 * If one dimension is empty, then all records on the other one must
 	 * be obviously changed.
 	 */
 	if (off1 == lim1) {
 		char *rchg2 = dd2->rchg;
 		long *rindex2 = dd2->rindex;
 
 		for (; off2 < lim2; off2++)
 			rchg2[rindex2[off2]] = 1;
 	} else if (off2 == lim2) {
 		char *rchg1 = dd1->rchg;
 		long *rindex1 = dd1->rindex;
 
 		for (; off1 < lim1; off1++)
 			rchg1[rindex1[off1]] = 1;
 	} else {
 		xdpsplit_t spl;
 		spl.i1 = spl.i2 = 0;
 
 		/*
 		 * Divide ...
 		 */
 		if (xdl_split(ha1, off1, lim1, ha2, off2, lim2, kvdf, kvdb,
 			      need_min, &spl, xenv) < 0) {
 
 			return -1;
 		}
 
 		/*
 		 * ... et Impera.
 		 */
 		if (xdl_recs_cmp(dd1, off1, spl.i1, dd2, off2, spl.i2,
 				 kvdf, kvdb, spl.min_lo, xenv) < 0 ||
 		    xdl_recs_cmp(dd1, spl.i1, lim1, dd2, spl.i2, lim2,
 				 kvdf, kvdb, spl.min_hi, xenv) < 0) {
 
 			return -1;
 		}
 	}
 
 	return 0;
 }
 
 
 int xdl_do_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
 		xdfenv_t *xe) {
 	long ndiags;
 	long *kvd, *kvdf, *kvdb;
 	xdalgoenv_t xenv;
 	diffdata_t dd1, dd2;
 
 	if (xdl_prepare_env(mf1, mf2, xpp, xe) < 0) {
 
 		return -1;
 	}
 
 	/*
 	 * Allocate and setup K vectors to be used by the differential algorithm.
 	 * 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)))) {
 
 		xdl_free_env(xe);
 		return -1;
 	}
 	kvdf = kvd;
 	kvdb = kvdf + ndiags;
 	kvdf += xe->xdf2.nreff + 1;
 	kvdb += xe->xdf2.nreff + 1;
 
 	xenv.mxcost = xdl_bogosqrt(ndiags);
 	if (xenv.mxcost < XDL_MAX_COST_MIN)
 		xenv.mxcost = XDL_MAX_COST_MIN;
 	xenv.snake_cnt = XDL_SNAKE_CNT;
 	xenv.heur_min = XDL_HEUR_MIN_COST;
 
 	dd1.nrec = xe->xdf1.nreff;
 	dd1.ha = xe->xdf1.ha;
 	dd1.rchg = xe->xdf1.rchg;
 	dd1.rindex = xe->xdf1.rindex;
 	dd2.nrec = xe->xdf2.nreff;
 	dd2.ha = xe->xdf2.ha;
 	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;
 	}
 
 	xdl_free(kvd);
 
 	return 0;
 }
 
 
 static xdchange_t *xdl_add_change(xdchange_t *xscr, long i1, long i2, long chg1, long chg2) {
 	xdchange_t *xch;
 
 	if (!(xch = (xdchange_t *) xdl_malloc(sizeof(xdchange_t))))
 		return NULL;
 
 	xch->next = xscr;
 	xch->i1 = i1;
 	xch->i2 = i2;
 	xch->chg1 = chg1;
 	xch->chg2 = chg2;
 	xch->ignore = 0;
 
 	return xch;
 }
 
 
 static int recs_match(xrecord_t *rec1, xrecord_t *rec2, long flags)
 {
 	return (rec1->ha == rec2->ha &&
 		xdl_recmatch(rec1->ptr, rec1->size,
 			     rec2->ptr, rec2->size,
 			     flags));
 }
 
 /*
  * If a line is indented more than this, get_indent() just returns this value.
  * This avoids having to do absurd amounts of work for data that are not
  * human-readable text, and also ensures that the output of get_indent fits within
  * an int.
  */
 #define MAX_INDENT 200
 
 /*
  * Return the amount of indentation of the specified line, treating TAB as 8
  * columns. Return -1 if line is empty or contains only whitespace. Clamp the
  * output value at MAX_INDENT.
  */
 static int get_indent(xrecord_t *rec)
 {
 	long i;
 	int ret = 0;
 
 	for (i = 0; i < rec->size; i++) {
 		char c = rec->ptr[i];
 
 		if (!XDL_ISSPACE(c))
 			return ret;
 		else if (c == ' ')
 			ret += 1;
 		else if (c == '\t')
 			ret += 8 - ret % 8;
 		/* ignore other whitespace characters */
 
 		if (ret >= MAX_INDENT)
 			return MAX_INDENT;
 	}
 
 	/* The line contains only whitespace. */
 	return -1;
 }
 
 /*
  * If more than this number of consecutive blank rows are found, just return this
  * value. This avoids requiring O(N^2) work for pathological cases, and also
  * ensures that the output of score_split fits in an int.
  */
 #define MAX_BLANKS 20
 
 /* Characteristics measured about a hypothetical split position. */
 struct split_measurement {
 	/*
 	 * Is the split at the end of the file (aside from any blank lines)?
 	 */
 	int end_of_file;
 
 	/*
 	 * How much is the line immediately following the split indented (or -1 if
 	 * the line is blank):
 	 */
 	int indent;
 
 	/*
 	 * How many consecutive lines above the split are blank?
 	 */
 	int pre_blank;
 
 	/*
 	 * How much is the nearest non-blank line above the split indented (or -1
 	 * if there is no such line)?
 	 */
 	int pre_indent;
 
 	/*
 	 * How many lines after the line following the split are blank?
 	 */
 	int post_blank;
 
 	/*
 	 * How much is the nearest non-blank line after the line following the
 	 * split indented (or -1 if there is no such line)?
 	 */
 	int post_indent;
 };
 
 struct split_score {
 	/* The effective indent of this split (smaller is preferred). */
 	int effective_indent;
 
 	/* Penalty for this split (smaller is preferred). */
 	int penalty;
 };
 
 /*
  * Fill m with information about a hypothetical split of xdf above line split.
  */
 static void measure_split(const xdfile_t *xdf, long split,
 			  struct split_measurement *m)
 {
 	long i;
 
 	if (split >= xdf->nrec) {
 		m->end_of_file = 1;
 		m->indent = -1;
 	} else {
 		m->end_of_file = 0;
 		m->indent = get_indent(xdf->recs[split]);
 	}
 
 	m->pre_blank = 0;
 	m->pre_indent = -1;
 	for (i = split - 1; i >= 0; i--) {
 		m->pre_indent = get_indent(xdf->recs[i]);
 		if (m->pre_indent != -1)
 			break;
 		m->pre_blank += 1;
 		if (m->pre_blank == MAX_BLANKS) {
 			m->pre_indent = 0;
 			break;
 		}
 	}
 
 	m->post_blank = 0;
 	m->post_indent = -1;
 	for (i = split + 1; i < xdf->nrec; i++) {
 		m->post_indent = get_indent(xdf->recs[i]);
 		if (m->post_indent != -1)
 			break;
 		m->post_blank += 1;
 		if (m->post_blank == MAX_BLANKS) {
 			m->post_indent = 0;
 			break;
 		}
 	}
 }
 
 /*
  * The empirically-determined weight factors used by score_split() below.
  * Larger values means that the position is a less favorable place to split.
  *
  * Note that scores are only ever compared against each other, so multiplying
  * all of these weight/penalty values by the same factor wouldn't change the
  * heuristic's behavior. Still, we need to set that arbitrary scale *somehow*.
  * In practice, these numbers are chosen to be large enough that they can be
  * adjusted relative to each other with sufficient precision despite using
  * integer math.
  */
 
 /* Penalty if there are no non-blank lines before the split */
 #define START_OF_FILE_PENALTY 1
 
 /* Penalty if there are no non-blank lines after the split */
 #define END_OF_FILE_PENALTY 21
 
 /* Multiplier for the number of blank lines around the split */
 #define TOTAL_BLANK_WEIGHT (-30)
 
 /* Multiplier for the number of blank lines after the split */
 #define POST_BLANK_WEIGHT 6
 
 /*
  * Penalties applied if the line is indented more than its predecessor
  */
 #define RELATIVE_INDENT_PENALTY (-4)
 #define RELATIVE_INDENT_WITH_BLANK_PENALTY 10
 
 /*
  * Penalties applied if the line is indented less than both its predecessor and
  * its successor
  */
 #define RELATIVE_OUTDENT_PENALTY 24
 #define RELATIVE_OUTDENT_WITH_BLANK_PENALTY 17
 
 /*
  * Penalties applied if the line is indented less than its predecessor but not
  * less than its successor
  */
 #define RELATIVE_DEDENT_PENALTY 23
 #define RELATIVE_DEDENT_WITH_BLANK_PENALTY 17
 
 /*
  * We only consider whether the sum of the effective indents for splits are
  * less than (-1), equal to (0), or greater than (+1) each other. The resulting
  * value is multiplied by the following weight and combined with the penalty to
  * determine the better of two scores.
  */
 #define INDENT_WEIGHT 60
 
 /*
  * Compute a badness score for the hypothetical split whose measurements are
  * stored in m. The weight factors were determined empirically using the tools and
  * corpus described in
  *
  *     https://github.com/mhagger/diff-slider-tools
  *
  * Also see that project if you want to improve the weights based on, for example,
  * a larger or more diverse corpus.
  */
 static void score_add_split(const struct split_measurement *m, struct split_score *s)
 {
 	/*
 	 * A place to accumulate penalty factors (positive makes this index more
 	 * favored):
 	 */
 	int post_blank, total_blank, indent, any_blanks;
 
 	if (m->pre_indent == -1 && m->pre_blank == 0)
 		s->penalty += START_OF_FILE_PENALTY;
 
 	if (m->end_of_file)
 		s->penalty += END_OF_FILE_PENALTY;
 
 	/*
 	 * Set post_blank to the number of blank lines following the split,
 	 * including the line immediately after the split:
 	 */
 	post_blank = (m->indent == -1) ? 1 + m->post_blank : 0;
 	total_blank = m->pre_blank + post_blank;
 
 	/* Penalties based on nearby blank lines: */
 	s->penalty += TOTAL_BLANK_WEIGHT * total_blank;
 	s->penalty += POST_BLANK_WEIGHT * post_blank;
 
 	if (m->indent != -1)
 		indent = m->indent;
 	else
 		indent = m->post_indent;
 
 	any_blanks = (total_blank != 0);
 
 	/* Note that the effective indent is -1 at the end of the file: */
 	s->effective_indent += indent;
 
 	if (indent == -1) {
 		/* No additional adjustments needed. */
 	} else if (m->pre_indent == -1) {
 		/* No additional adjustments needed. */
 	} else if (indent > m->pre_indent) {
 		/*
 		 * The line is indented more than its predecessor.
 		 */
 		s->penalty += any_blanks ?
 			RELATIVE_INDENT_WITH_BLANK_PENALTY :
 			RELATIVE_INDENT_PENALTY;
 	} else if (indent == m->pre_indent) {
 		/*
 		 * The line has the same indentation level as its predecessor.
 		 * No additional adjustments needed.
 		 */
 	} else {
 		/*
 		 * The line is indented less than its predecessor. It could be
 		 * the block terminator of the previous block, but it could
 		 * also be the start of a new block (e.g., an "else" block, or
 		 * maybe the previous block didn't have a block terminator).
 		 * Try to distinguish those cases based on what comes next:
 		 */
 		if (m->post_indent != -1 && m->post_indent > indent) {
 			/*
 			 * The following line is indented more. So it is likely
 			 * that this line is the start of a block.
 			 */
 			s->penalty += any_blanks ?
 				RELATIVE_OUTDENT_WITH_BLANK_PENALTY :
 				RELATIVE_OUTDENT_PENALTY;
 		} else {
 			/*
 			 * That was probably the end of a block.
 			 */
 			s->penalty += any_blanks ?
 				RELATIVE_DEDENT_WITH_BLANK_PENALTY :
 				RELATIVE_DEDENT_PENALTY;
 		}
 	}
 }
 
 static int score_cmp(struct split_score *s1, struct split_score *s2)
 {
 	/* -1 if s1.effective_indent < s2->effective_indent, etc. */
 	int cmp_indents = ((s1->effective_indent > s2->effective_indent) -
 			   (s1->effective_indent < s2->effective_indent));
 
 	return INDENT_WEIGHT * cmp_indents + (s1->penalty - s2->penalty);
 }
 
 /*
  * Represent a group of changed lines in an xdfile_t (i.e., a contiguous group
  * of lines that was inserted or deleted from the corresponding version of the
  * file). We consider there to be such a group at the beginning of the file, at
  * the end of the file, and between any two unchanged lines, though most such
  * groups will usually be empty.
  *
  * If the first line in a group is equal to the line following the group, then
  * the group can be slid down. Similarly, if the last line in a group is equal
  * to the line preceding the group, then the group can be slid up. See
  * group_slide_down() and group_slide_up().
  *
  * Note that loops that are testing for changed lines in xdf->rchg do not need
  * index bounding since the array is prepared with a zero at position -1 and N.
  */
 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;
 
 	/*
 	 * The index of the first unchanged line after the group. For an empty
 	 * group, end is equal to start.
 	 */
 	long end;
 };
 
 /*
  * Initialize g to point at the first group in xdf.
  */
 static void group_init(xdfile_t *xdf, struct xdlgroup *g)
 {
 	g->start = g->end = 0;
 	while (xdf->rchg[g->end])
 		g->end++;
 }
 
 /*
  * Move g to describe the next (possibly empty) group in xdf and return 0. If g
  * is already at the end of the file, do nothing and return -1.
  */
 static inline int group_next(xdfile_t *xdf, struct xdlgroup *g)
 {
 	if (g->end == xdf->nrec)
 		return -1;
 
 	g->start = g->end + 1;
 	for (g->end = g->start; xdf->rchg[g->end]; g->end++)
 		;
 
 	return 0;
 }
 
 /*
  * Move g to describe the previous (possibly empty) group in xdf and return 0.
  * If g is already at the beginning of the file, do nothing and return -1.
  */
 static inline int group_previous(xdfile_t *xdf, struct xdlgroup *g)
 {
 	if (g->start == 0)
 		return -1;
 
 	g->end = g->start - 1;
 	for (g->start = g->end; xdf->rchg[g->start - 1]; g->start--)
 		;
 
 	return 0;
 }
 
 /*
  * If g can be slid toward the end of the file, do so, and if it bumps into a
  * 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)
 {
 	if (g->end < xdf->nrec &&
 	    recs_match(xdf->recs[g->start], xdf->recs[g->end], flags)) {
 		xdf->rchg[g->start++] = 0;
 		xdf->rchg[g->end++] = 1;
 
 		while (xdf->rchg[g->end])
 			g->end++;
 
 		return 0;
 	} else {
 		return -1;
 	}
 }
 
 /*
  * If g can be slid toward the beginning of the file, do so, and if it bumps
  * 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)
 {
 	if (g->start > 0 &&
 	    recs_match(xdf->recs[g->start - 1], xdf->recs[g->end - 1], flags)) {
 		xdf->rchg[--g->start] = 1;
 		xdf->rchg[--g->end] = 0;
 
 		while (xdf->rchg[g->start - 1])
 			g->start--;
 
 		return 0;
 	} else {
 		return -1;
 	}
 }
 
 static void xdl_bug(const char *msg)
 {
 	fprintf(stderr, "BUG: %s\n", msg);
 	exit(1);
 }
 
 /*
  * For indentation heuristic, skip searching for better slide position after
  * checking MAX_BORING lines without finding an improvement. This defends the
  * indentation heuristic logic against pathological cases. The value is not
  * picked scientifically but should be good enough.
  */
 #define MAX_BORING 100
 
 /*
  * Move back and forward change groups for a consistent and pretty diff output.
  * 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) {
 	struct xdlgroup g, go;
 	long earliest_end, end_matching_other;
 	long groupsize;
 
 	group_init(xdf, &g);
 	group_init(xdfo, &go);
 
 	while (1) {
 		/* If the group is empty in the to-be-compacted file, skip it: */
 		if (g.end == g.start)
 			goto next;
 
 		/*
 		 * Now shift the change up and then down as far as possible in
 		 * each direction. If it bumps into any other changes, merge them.
 		 */
 		do {
 			groupsize = g.end - g.start;
 
 			/*
 			 * Keep track of the last "end" index that causes this
 			 * group to align with a group of changed lines in the
 			 * other file. -1 indicates that we haven't found such
 			 * a match yet:
 			 */
 			end_matching_other = -1;
 
 			/* Shift the group backward as much as possible: */
 			while (!group_slide_up(xdf, &g, flags))
 				if (group_previous(xdfo, &go))
 					xdl_bug("group sync broken sliding up");
 
 			/*
 			 * This is this highest that this group can be shifted.
 			 * Record its end index:
 			 */
 			earliest_end = g.end;
 
 			if (go.end > go.start)
 				end_matching_other = g.end;
 
 			/* Now shift the group forward as far as possible: */
 			while (1) {
 				if (group_slide_down(xdf, &g, flags))
 					break;
 				if (group_next(xdfo, &go))
 					xdl_bug("group sync broken sliding down");
 
 				if (go.end > go.start)
 					end_matching_other = g.end;
 			}
 		} while (groupsize != g.end - g.start);
 
 		/*
 		 * If the group can be shifted, then we can possibly use this
 		 * freedom to produce a more intuitive diff.
 		 *
 		 * The group is currently shifted as far down as possible, so the
 		 * heuristics below only have to handle upwards shifts.
 		 */
 
 		if (g.end == earliest_end) {
 			/* no shifting was possible */
 		} else if (end_matching_other != -1) {
 			/*
 			 * Move the possibly merged group of changes back to line
 			 * up with the last group of changes from the other file
 			 * that it can align with.
 			 */
 			while (go.end == go.start) {
 				if (group_slide_up(xdf, &g, flags))
 					xdl_bug("match disappeared");
 				if (group_previous(xdfo, &go))
 					xdl_bug("group sync broken sliding to match");
 			}
 		} else if (flags & XDF_INDENT_HEURISTIC) {
 			/*
 			 * Indent heuristic: a group of pure add/delete lines
 			 * implies two splits, one between the end of the "before"
 			 * context and the start of the group, and another between
 			 * the end of the group and the beginning of the "after"
 			 * context. Some splits are aesthetically better and some
 			 * are worse. We compute a badness "score" for each split,
 			 * and add the scores for the two splits to define a
 			 * "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;
 			struct split_score best_score;
 
 			/*
 			 * This is O(N * MAX_BLANKS) (N = shift-able lines).
 			 * Even with MAX_BLANKS bounded to a small value, a
 			 * large N could still make this loop take several
 			 * times longer than the main diff algorithm. The
 			 * "boring" value is to help cut down N to something
 			 * like (MAX_BORING + groupsize).
 			 *
 			 * Scan from bottom to top. So we can exit the loop
 			 * without compromising the assumption "for a same best
 			 * score, pick the bottommost shift".
 			 */
 			int boring = 0;
 			for (shift = g.end; shift >= earliest_end; shift--) {
 				struct split_measurement m;
 				struct split_score score = {0, 0};
 				int cmp;
 
 				measure_split(xdf, shift, &m);
 				score_add_split(&m, &score);
 				measure_split(xdf, shift - groupsize, &m);
 				score_add_split(&m, &score);
 
 				if (best_shift == -1) {
 					cmp = -1;
 				} else {
 					cmp = score_cmp(&score, &best_score);
 				}
 				if (cmp < 0) {
 					boring = 0;
 					best_score.effective_indent = score.effective_indent;
 					best_score.penalty = score.penalty;
 					best_shift = shift;
 				} else {
 					boring += 1;
 					if (boring >= MAX_BORING)
 						break;
 				}
 			}
 
 			while (g.end > best_shift) {
 				if (group_slide_up(xdf, &g, flags))
 					xdl_bug("best shift unreached");
 				if (group_previous(xdfo, &go))
 					xdl_bug("group sync broken sliding to blank line");
 			}
 		}
 
 	next:
 		/* Move past the just-processed group: */
 		if (group_next(xdf, &g))
 			break;
 		if (group_next(xdfo, &go))
 			xdl_bug("group sync broken moving to next group");
 	}
 
 	if (!group_next(xdfo, &go))
 		xdl_bug("group sync broken at end of file");
 
 	return 0;
 }
 
 
 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;
 
 	/*
 	 * Trivial. Collects "groups" of changes and creates an edit script.
 	 */
 	for (i1 = xe->xdf1.nrec, i2 = xe->xdf2.nrec; i1 >= 0 || i2 >= 0; i1--, i2--)
 		if (rchg1[i1 - 1] || rchg2[i2 - 1]) {
 			for (l1 = i1; rchg1[i1 - 1]; i1--);
 			for (l2 = i2; rchg2[i2 - 1]; i2--);
 
 			if (!(xch = xdl_add_change(cscr, i1, i2, l1 - i1, l2 - i2))) {
 				xdl_free_script(cscr);
 				return -1;
 			}
 			cscr = xch;
 		}
 
 	*xscr = cscr;
 
 	return 0;
 }
 
 
 void xdl_free_script(xdchange_t *xscr) {
 	xdchange_t *xch;
 
 	while ((xch = xscr) != NULL) {
 		xscr = xscr->next;
 		xdl_free(xch);
 	}
 }
 
+
+/*
+ * Starting at the passed change atom, find the latest change atom to be included
+ * inside the differential hunk according to the specified configuration.
+ * Also advance xscr if the first changes must be discarded.
+ */
+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 */
+
+	/* remove ignorable changes that are too far before other changes */
+	for (xchp = *xscr; xchp && xchp->ignore; xchp = xchp->next) {
+		xch = xchp->next;
+
+		if (xch == NULL ||
+		    xch->i1 - (xchp->i1 + xchp->chg1) >= max_ignorable)
+			*xscr = xch;
+	}
+
+	if (*xscr == NULL)
+		return NULL;
+
+	lxch = *xscr;
+
+	for (xchp = *xscr, xch = xchp->next; xch; xchp = xch, xch = xch->next) {
+		long distance = xch->i1 - (xchp->i1 + xchp->chg1);
+		if (distance > max_common)
+			break;
+
+		if (distance < max_ignorable && (!xch->ignore || lxch == xchp)) {
+			lxch = xch;
+			ignored = 0;
+		} else if (distance < max_ignorable && xch->ignore) {
+			ignored += xch->chg2;
+		} else if (lxch != xchp &&
+			   xch->i1 + ignored - (lxch->i1 + lxch->chg1) > max_common) {
+			break;
+		} else if (!xch->ignore) {
+			lxch = xch;
+			ignored = 0;
+		} else {
+			ignored += xch->chg2;
+		}
+	}
+
+	return lxch;
+}
+
+
 static int xdl_call_hunk_func(xdfenv_t *xe, xdchange_t *xscr, xdemitcb_t *ecb,
 			      xdemitconf_t const *xecfg)
 {
 	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;
 		for (xch = xscr; xch; xch = xche->next) {
 			xche = xdl_get_hunk(&xch, xecfg);
 			if (!xch)
 				break;
 			if (xch->i1 > i1 || xch->i2 > i2) {
 				if (xecfg->hunk_func(i1, xch->i1, i2, xch->i2, ecb->priv) < 0)
 					return -1;
 			}
 			i1 = xche->i1 + xche->chg1;
 			i2 = xche->i2 + xche->chg2;
 		}
 		if (xecfg->hunk_func(i1, n1, i2, n2, ecb->priv) < 0)
 			return -1;
 	} else {
 		for (xch = xscr; xch; xch = xche->next) {
 			xche = xdl_get_hunk(&xch, xecfg);
 			if (!xch)
 				break;
 			if (xecfg->hunk_func(
 					xch->i1, xche->i1 + xche->chg1 - xch->i1,
 					xch->i2, xche->i2 + xche->chg2 - xch->i2,
 					ecb->priv) < 0)
 				return -1;
 		}
 	}
 	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) {
 
 		return -1;
 	}
 	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) {
 
 		xdl_free_env(&xe);
 		return -1;
 	}
 
-	if (ef(&xe, xscr, ecb, xecfg) < 0) {
+	if (xdl_call_hunk_func(&xe, xscr, ecb, xecfg) < 0) {
 		xdl_free_script(xscr);
 		xdl_free_env(&xe);
 		return -1;
 	}
 	xdl_free_script(xscr);
 	xdl_free_env(&xe);
 
 	return 0;
 }

mercurial/thirdparty/xdiff/xdiffi.h

@@ -1,60 +1,58 b''
 /*
  *  LibXDiff by Davide Libenzi ( File Differential Library )
  *  Copyright (C) 2003  Davide Libenzi
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
  *  version 2.1 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this library; if not, see
  *  <http://www.gnu.org/licenses/>.
  *
  *  Davide Libenzi <[e-mail]>
  *
  */
 
 #if !defined(XDIFFI_H)
 #define XDIFFI_H
 
 
 typedef struct s_diffdata {
 	long nrec;
 	unsigned long const *ha;
 	long *rindex;
 	char *rchg;
 } diffdata_t;
 
 typedef struct s_xdalgoenv {
 	long mxcost;
 	long snake_cnt;
 	long heur_min;
 } xdalgoenv_t;
 
 typedef struct s_xdchange {
 	struct s_xdchange *next;
 	long i1, i2;
 	long 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_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_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);
 
 #endif /* #if !defined(XDIFFI_H) */

mercurial/thirdparty/xdiff/xinclude.h

@@ -1,41 +1,40 b''
 /*
  *  LibXDiff by Davide Libenzi ( File Differential Library )
  *  Copyright (C) 2003  Davide Libenzi
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
  *  version 2.1 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this library; if not, see
  *  <http://www.gnu.org/licenses/>.
  *
  *  Davide Libenzi <[e-mail]>
  *
  */
 
 #if !defined(XINCLUDE_H)
 #define XINCLUDE_H
 
 #include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <limits.h>
 
 #include "xmacros.h"
 #include "xdiff.h"
 #include "xtypes.h"
 #include "xutils.h"
 #include "xprepare.h"
 #include "xdiffi.h"
-#include "xemit.h"
 
 
 #endif /* #if !defined(XINCLUDE_H) */

mercurial/thirdparty/xdiff/xutils.c

@@ -1,243 +1,149 b''
 /*
  *  LibXDiff by Davide Libenzi ( File Differential Library )
  *  Copyright (C) 2003	Davide Libenzi
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
  *  version 2.1 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this library; if not, see
  *  <http://www.gnu.org/licenses/>.
  *
  *  Davide Libenzi <[e-mail]>
  *
  */
 
 #include <limits.h>
 #include <assert.h>
 #include "xinclude.h"
 
 
 
 
 long xdl_bogosqrt(long n) {
 	long i;
 
 	/*
 	 * Classical integer square root approximation using shifts.
 	 */
 	for (i = 1; n > 0; n >>= 2)
 		i <<= 1;
 
 	return i;
 }
 
 
-int xdl_emit_diffrec(char const *rec, long size, char const *pre, long psize,
-		     xdemitcb_t *ecb) {
-	int i = 2;
-	mmbuffer_t mb[3];
-
-	mb[0].ptr = (char *) pre;
-	mb[0].size = psize;
-	mb[1].ptr = (char *) rec;
-	mb[1].size = size;
-	if (size > 0 && rec[size - 1] != '\n') {
-		mb[2].ptr = (char *) "\n\\ No newline at end of file\n";
-		mb[2].size = strlen(mb[2].ptr);
-		i++;
-	}
-	if (ecb->outf(ecb->priv, mb, i) < 0) {
-
-		return -1;
-	}
-
-	return 0;
-}
-
 void *xdl_mmfile_first(mmfile_t *mmf, long *size)
 {
 	*size = mmf->size;
 	return mmf->ptr;
 }
 
 
 long xdl_mmfile_size(mmfile_t *mmf)
 {
 	return mmf->size;
 }
 
 
 int xdl_cha_init(chastore_t *cha, long isize, long icount) {
 
 	cha->head = cha->tail = NULL;
 	cha->isize = isize;
 	cha->nsize = icount * isize;
 	cha->ancur = cha->sncur = NULL;
 	cha->scurr = 0;
 
 	return 0;
 }
 
 
 void xdl_cha_free(chastore_t *cha) {
 	chanode_t *cur, *tmp;
 
 	for (cur = cha->head; (tmp = cur) != NULL;) {
 		cur = cur->next;
 		xdl_free(tmp);
 	}
 }
 
 
 void *xdl_cha_alloc(chastore_t *cha) {
 	chanode_t *ancur;
 	void *data;
 
 	if (!(ancur = cha->ancur) || ancur->icurr == cha->nsize) {
 		if (!(ancur = (chanode_t *) xdl_malloc(sizeof(chanode_t) + cha->nsize))) {
 
 			return NULL;
 		}
 		ancur->icurr = 0;
 		ancur->next = NULL;
 		if (cha->tail)
 			cha->tail->next = ancur;
 		if (!cha->head)
 			cha->head = ancur;
 		cha->tail = ancur;
 		cha->ancur = ancur;
 	}
 
 	data = (char *) ancur + sizeof(chanode_t) + ancur->icurr;
 	ancur->icurr += cha->isize;
 
 	return data;
 }
 
 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) {
 		for (top = data + size; nl < sample && cur < top; ) {
 			nl++;
 			if (!(cur = memchr(cur, '\n', top - cur)))
 				cur = top;
 			else
 				cur++;
 		}
 		tsize += (long) (cur - data);
 	}
 
 	if (nl && tsize)
 		nl = xdl_mmfile_size(mf) / (tsize / nl);
 
 	return nl + 1;
 }
 
 int xdl_recmatch(const char *l1, long s1, const char *l2, long s2, long 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;
 	char const *ptr = *data;
 
 	for (; ptr < top && *ptr != '\n'; ptr++) {
 		ha += (ha << 5);
 		ha ^= (unsigned long) *ptr;
 	}
 	*data = ptr < top ? ptr + 1: ptr;
 
 	return ha;
 }
 
 unsigned int xdl_hashbits(unsigned int size) {
 	unsigned int val = 1, bits = 0;
 
 	for (; val < size && bits < CHAR_BIT * sizeof(unsigned int); val <<= 1, bits++);
 	return bits ? bits: 1;
 }
-
-
-int xdl_num_out(char *out, long val) {
-	char *ptr, *str = out;
-	char buf[32];
-
-	ptr = buf + sizeof(buf) - 1;
-	*ptr = '\0';
-	if (val < 0) {
-		*--ptr = '-';
-		val = -val;
-	}
-	for (; val && ptr > buf; val /= 10)
-		*--ptr = "0123456789"[val % 10];
-	if (*ptr)
-		for (; *ptr; ptr++, str++)
-			*str = *ptr;
-	else
-		*str++ = '0';
-	*str = '\0';
-
-	return str - out;
-}
-
-int xdl_emit_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];
-
-	memcpy(buf, "@@ -", 4);
-	nb += 4;
-
-	nb += xdl_num_out(buf + nb, c1 ? s1: s1 - 1);
-
-	if (c1 != 1) {
-		memcpy(buf + nb, ",", 1);
-		nb += 1;
-
-		nb += xdl_num_out(buf + nb, c1);
-	}
-
-	memcpy(buf + nb, " +", 2);
-	nb += 2;
-
-	nb += xdl_num_out(buf + nb, c2 ? s2: s2 - 1);
-
-	if (c2 != 1) {
-		memcpy(buf + nb, ",", 1);
-		nb += 1;
-
-		nb += xdl_num_out(buf + nb, c2);
-	}
-
-	memcpy(buf + nb, " @@", 3);
-	nb += 3;
-	if (func && funclen) {
-		buf[nb++] = ' ';
-		if (funclen > sizeof(buf) - nb - 1)
-			funclen = sizeof(buf) - nb - 1;
-		memcpy(buf + nb, func, funclen);
-		nb += funclen;
-	}
-	buf[nb++] = '\n';
-
-	mb.ptr = buf;
-	mb.size = nb;
-	if (ecb->outf(ecb->priv, &mb, 1) < 0)
-		return -1;
-
-	return 0;
-}

mercurial/thirdparty/xdiff/xutils.h

@@ -1,44 +1,39 b''
 /*
  *  LibXDiff by Davide Libenzi ( File Differential Library )
  *  Copyright (C) 2003  Davide Libenzi
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
  *  License as published by the Free Software Foundation; either
  *  version 2.1 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this library; if not, see
  *  <http://www.gnu.org/licenses/>.
  *
  *  Davide Libenzi <[e-mail]>
  *
  */
 
 #if !defined(XUTILS_H)
 #define XUTILS_H
 
 
 
 long xdl_bogosqrt(long n);
-int xdl_emit_diffrec(char const *rec, long size, char const *pre, long psize,
-		     xdemitcb_t *ecb);
 int xdl_cha_init(chastore_t *cha, long isize, long 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);
 unsigned int xdl_hashbits(unsigned int size);
-int xdl_num_out(char *out, long val);
-int xdl_emit_hunk_hdr(long s1, long c1, long s2, long c2,
-		      const char *func, long funclen, xdemitcb_t *ecb);
 
 
 
 #endif /* #if !defined(XUTILS_H) */

setup.py

@@ -1,1075 +1,1073 b''
 #
 # This is the mercurial setup script.
 #
 # 'python setup.py install', or
 # 'python setup.py --help' for more options
 
 import os
 
 supportedpy = '~= 2.7'
 if os.environ.get('HGALLOWPYTHON3', ''):
     # Mercurial will never work on Python 3 before 3.5 due to a lack
     # of % formatting on bytestrings, and can't work on 3.6.0 or 3.6.1
     # due to a bug in % formatting in bytestrings.
     #
     # TODO: when we actually work on Python 3, use this string as the
     # actual supportedpy string.
     supportedpy = ','.join([
         '>=2.7',
         '!=3.0.*',
         '!=3.1.*',
         '!=3.2.*',
         '!=3.3.*',
         '!=3.4.*',
         '!=3.6.0',
         '!=3.6.1',
     ])
 
 import sys, platform
 if sys.version_info[0] >= 3:
     printf = eval('print')
     libdir_escape = 'unicode_escape'
     def sysstr(s):
         return s.decode('latin-1')
 else:
     libdir_escape = 'string_escape'
     def printf(*args, **kwargs):
         f = kwargs.get('file', sys.stdout)
         end = kwargs.get('end', '\n')
         f.write(b' '.join(args) + end)
     def sysstr(s):
         return s
 
 # Attempt to guide users to a modern pip - this means that 2.6 users
 # should have a chance of getting a 4.2 release, and when we ratchet
 # the version requirement forward again hopefully everyone will get
 # something that works for them.
 if sys.version_info < (2, 7, 0, 'final'):
     pip_message = ('This may be due to an out of date pip. '
                    'Make sure you have pip >= 9.0.1.')
     try:
         import pip
         pip_version = tuple([int(x) for x in pip.__version__.split('.')[:3]])
         if pip_version < (9, 0, 1) :
             pip_message = (
                 'Your pip version is out of date, please install '
                 'pip >= 9.0.1. pip {} detected.'.format(pip.__version__))
         else:
             # pip is new enough - it must be something else
             pip_message = ''
     except Exception:
         pass
     error = """
 Mercurial does not support Python older than 2.7.
 Python {py} detected.
 {pip}
 """.format(py=sys.version_info, pip=pip_message)
     printf(error, file=sys.stderr)
     sys.exit(1)
 
 # We don't yet officially support Python 3. But we want to allow developers to
 # hack on. Detect and disallow running on Python 3 by default. But provide a
 # backdoor to enable working on Python 3.
 if sys.version_info[0] != 2:
     badpython = True
 
     # Allow Python 3 from source checkouts.
     if os.path.isdir('.hg'):
         badpython = False
 
     if badpython:
         error = """
 Mercurial only supports Python 2.7.
 Python {py} detected.
 Please re-run with Python 2.7.
 """.format(py=sys.version_info)
 
         printf(error, file=sys.stderr)
         sys.exit(1)
 
 # Solaris Python packaging brain damage
 try:
     import hashlib
     sha = hashlib.sha1()
 except ImportError:
     try:
         import sha
         sha.sha # silence unused import warning
     except ImportError:
         raise SystemExit(
             "Couldn't import standard hashlib (incomplete Python install).")
 
 try:
     import zlib
     zlib.compressobj # silence unused import warning
 except ImportError:
     raise SystemExit(
         "Couldn't import standard zlib (incomplete Python install).")
 
 # The base IronPython distribution (as of 2.7.1) doesn't support bz2
 isironpython = False
 try:
     isironpython = (platform.python_implementation()
                     .lower().find("ironpython") != -1)
 except AttributeError:
     pass
 
 if isironpython:
     sys.stderr.write("warning: IronPython detected (no bz2 support)\n")
 else:
     try:
         import bz2
         bz2.BZ2Compressor # silence unused import warning
     except ImportError:
         raise SystemExit(
             "Couldn't import standard bz2 (incomplete Python install).")
 
 ispypy = "PyPy" in sys.version
 
 import ctypes
 import stat, subprocess, time
 import re
 import shutil
 import tempfile
 from distutils import log
 # We have issues with setuptools on some platforms and builders. Until
 # those are resolved, setuptools is opt-in except for platforms where
 # we don't have issues.
 issetuptools = (os.name == 'nt' or 'FORCE_SETUPTOOLS' in os.environ)
 if issetuptools:
     from setuptools import setup
 else:
     from distutils.core import setup
 from distutils.ccompiler import new_compiler
 from distutils.core import Command, Extension
 from distutils.dist import Distribution
 from distutils.command.build import build
 from distutils.command.build_ext import build_ext
 from distutils.command.build_py import build_py
 from distutils.command.build_scripts import build_scripts
 from distutils.command.install import install
 from distutils.command.install_lib import install_lib
 from distutils.command.install_scripts import install_scripts
 from distutils.spawn import spawn, find_executable
 from distutils import file_util
 from distutils.errors import (
     CCompilerError,
     DistutilsError,
     DistutilsExecError,
 )
 from distutils.sysconfig import get_python_inc, get_config_var
 from distutils.version import StrictVersion
 
 def write_if_changed(path, content):
     """Write content to a file iff the content hasn't changed."""
     if os.path.exists(path):
         with open(path, 'rb') as fh:
             current = fh.read()
     else:
         current = b''
 
     if current != content:
         with open(path, 'wb') as fh:
             fh.write(content)
 
 scripts = ['hg']
 if os.name == 'nt':
     # We remove hg.bat if we are able to build hg.exe.
     scripts.append('contrib/win32/hg.bat')
 
 def cancompile(cc, code):
     tmpdir = tempfile.mkdtemp(prefix='hg-install-')
     devnull = oldstderr = None
     try:
         fname = os.path.join(tmpdir, 'testcomp.c')
         f = open(fname, 'w')
         f.write(code)
         f.close()
         # Redirect stderr to /dev/null to hide any error messages
         # from the compiler.
         # This will have to be changed if we ever have to check
         # for a function on Windows.
         devnull = open('/dev/null', 'w')
         oldstderr = os.dup(sys.stderr.fileno())
         os.dup2(devnull.fileno(), sys.stderr.fileno())
         objects = cc.compile([fname], output_dir=tmpdir)
         cc.link_executable(objects, os.path.join(tmpdir, "a.out"))
         return True
     except Exception:
         return False
     finally:
         if oldstderr is not None:
             os.dup2(oldstderr, sys.stderr.fileno())
         if devnull is not None:
             devnull.close()
         shutil.rmtree(tmpdir)
 
 # simplified version of distutils.ccompiler.CCompiler.has_function
 # that actually removes its temporary files.
 def hasfunction(cc, funcname):
     code = 'int main(void) { %s(); }\n' % funcname
     return cancompile(cc, code)
 
 def hasheader(cc, headername):
     code = '#include <%s>\nint main(void) { return 0; }\n' % headername
     return cancompile(cc, code)
 
 # py2exe needs to be installed to work
 try:
     import py2exe
     py2exe.Distribution # silence unused import warning
     py2exeloaded = True
     # import py2exe's patched Distribution class
     from distutils.core import Distribution
 except ImportError:
     py2exeloaded = False
 
 def runcmd(cmd, env):
     p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE, env=env)
     out, err = p.communicate()
     return p.returncode, out, err
 
 class hgcommand(object):
     def __init__(self, cmd, env):
         self.cmd = cmd
         self.env = env
 
     def run(self, args):
         cmd = self.cmd + args
         returncode, out, err = runcmd(cmd, self.env)
         err = filterhgerr(err)
         if err or returncode != 0:
             printf("stderr from '%s':" % (' '.join(cmd)), file=sys.stderr)
             printf(err, file=sys.stderr)
             return ''
         return out
 
 def filterhgerr(err):
     # If root is executing setup.py, but the repository is owned by
     # another user (as in "sudo python setup.py install") we will get
     # trust warnings since the .hg/hgrc file is untrusted. That is
     # fine, we don't want to load it anyway.  Python may warn about
     # a missing __init__.py in mercurial/locale, we also ignore that.
     err = [e for e in err.splitlines()
            if (not e.startswith(b'not trusting file')
                and not e.startswith(b'warning: Not importing')
                and not e.startswith(b'obsolete feature not enabled')
                and not e.startswith(b'*** failed to import extension')
                and not e.startswith(b'devel-warn:'))]
     return b'\n'.join(b'  ' + e for e in err)
 
 def findhg():
     """Try to figure out how we should invoke hg for examining the local
     repository contents.
 
     Returns an hgcommand object."""
     # By default, prefer the "hg" command in the user's path.  This was
     # presumably the hg command that the user used to create this repository.
     #
     # This repository may require extensions or other settings that would not
     # be enabled by running the hg script directly from this local repository.
     hgenv = os.environ.copy()
     # Use HGPLAIN to disable hgrc settings that would change output formatting,
     # and disable localization for the same reasons.
     hgenv['HGPLAIN'] = '1'
     hgenv['LANGUAGE'] = 'C'
     hgcmd = ['hg']
     # Run a simple "hg log" command just to see if using hg from the user's
     # path works and can successfully interact with this repository.
     check_cmd = ['log', '-r.', '-Ttest']
     try:
         retcode, out, err = runcmd(hgcmd + check_cmd, hgenv)
     except EnvironmentError:
         retcode = -1
     if retcode == 0 and not filterhgerr(err):
         return hgcommand(hgcmd, hgenv)
 
     # Fall back to trying the local hg installation.
     hgenv = localhgenv()
     hgcmd = [sys.executable, 'hg']
     try:
         retcode, out, err = runcmd(hgcmd + check_cmd, hgenv)
     except EnvironmentError:
         retcode = -1
     if retcode == 0 and not filterhgerr(err):
         return hgcommand(hgcmd, hgenv)
 
     raise SystemExit('Unable to find a working hg binary to extract the '
                      'version from the repository tags')
 
 def localhgenv():
     """Get an environment dictionary to use for invoking or importing
     mercurial from the local repository."""
     # Execute hg out of this directory with a custom environment which takes
     # care to not use any hgrc files and do no localization.
     env = {'HGMODULEPOLICY': 'py',
            'HGRCPATH': '',
            'LANGUAGE': 'C',
            'PATH': ''} # make pypi modules that use os.environ['PATH'] happy
     if 'LD_LIBRARY_PATH' in os.environ:
         env['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH']
     if 'SystemRoot' in os.environ:
         # SystemRoot is required by Windows to load various DLLs.  See:
         # https://bugs.python.org/issue13524#msg148850
         env['SystemRoot'] = os.environ['SystemRoot']
     return env
 
 version = ''
 
 if os.path.isdir('.hg'):
     hg = findhg()
     cmd = ['log', '-r', '.', '--template', '{tags}\n']
     numerictags = [t for t in sysstr(hg.run(cmd)).split() if t[0:1].isdigit()]
     hgid = sysstr(hg.run(['id', '-i'])).strip()
     if not hgid:
         # Bail out if hg is having problems interacting with this repository,
         # rather than falling through and producing a bogus version number.
         # Continuing with an invalid version number will break extensions
         # that define minimumhgversion.
         raise SystemExit('Unable to determine hg version from local repository')
     if numerictags: # tag(s) found
         version = numerictags[-1]
         if hgid.endswith('+'): # propagate the dirty status to the tag
             version += '+'
     else: # no tag found
         ltagcmd = ['parents', '--template', '{latesttag}']
         ltag = sysstr(hg.run(ltagcmd))
         changessincecmd = ['log', '-T', 'x\n', '-r', "only(.,'%s')" % ltag]
         changessince = len(hg.run(changessincecmd).splitlines())
         version = '%s+%s-%s' % (ltag, changessince, hgid)
     if version.endswith('+'):
         version += time.strftime('%Y%m%d')
 elif os.path.exists('.hg_archival.txt'):
     kw = dict([[t.strip() for t in l.split(':', 1)]
                for l in open('.hg_archival.txt')])
     if 'tag' in kw:
         version = kw['tag']
     elif 'latesttag' in kw:
         if 'changessincelatesttag' in kw:
             version = '%(latesttag)s+%(changessincelatesttag)s-%(node).12s' % kw
         else:
             version = '%(latesttag)s+%(latesttagdistance)s-%(node).12s' % kw
     else:
         version = kw.get('node', '')[:12]
 
 if version:
     versionb = version
     if not isinstance(versionb, bytes):
         versionb = versionb.encode('ascii')
 
     write_if_changed('mercurial/__version__.py', b''.join([
         b'# this file is autogenerated by setup.py\n'
         b'version = "%s"\n' % versionb,
     ]))
 
 try:
     oldpolicy = os.environ.get('HGMODULEPOLICY', None)
     os.environ['HGMODULEPOLICY'] = 'py'
     from mercurial import __version__
     version = __version__.version
 except ImportError:
     version = 'unknown'
 finally:
     if oldpolicy is None:
         del os.environ['HGMODULEPOLICY']
     else:
         os.environ['HGMODULEPOLICY'] = oldpolicy
 
 class hgbuild(build):
     # Insert hgbuildmo first so that files in mercurial/locale/ are found
     # when build_py is run next.
     sub_commands = [('build_mo', None)] + build.sub_commands
 
 class hgbuildmo(build):
 
     description = "build translations (.mo files)"
 
     def run(self):
         if not find_executable('msgfmt'):
             self.warn("could not find msgfmt executable, no translations "
                      "will be built")
             return
 
         podir = 'i18n'
         if not os.path.isdir(podir):
             self.warn("could not find %s/ directory" % podir)
             return
 
         join = os.path.join
         for po in os.listdir(podir):
             if not po.endswith('.po'):
                 continue
             pofile = join(podir, po)
             modir = join('locale', po[:-3], 'LC_MESSAGES')
             mofile = join(modir, 'hg.mo')
             mobuildfile = join('mercurial', mofile)
             cmd = ['msgfmt', '-v', '-o', mobuildfile, pofile]
             if sys.platform != 'sunos5':
                 # msgfmt on Solaris does not know about -c
                 cmd.append('-c')
             self.mkpath(join('mercurial', modir))
             self.make_file([pofile], mobuildfile, spawn, (cmd,))
 
 
 class hgdist(Distribution):
     pure = False
     cffi = ispypy
 
     global_options = Distribution.global_options + \
                      [('pure', None, "use pure (slow) Python "
                         "code instead of C extensions"),
                      ]
 
     def has_ext_modules(self):
         # self.ext_modules is emptied in hgbuildpy.finalize_options which is
         # too late for some cases
         return not self.pure and Distribution.has_ext_modules(self)
 
 # This is ugly as a one-liner. So use a variable.
 buildextnegops = dict(getattr(build_ext, 'negative_options', {}))
 buildextnegops['no-zstd'] = 'zstd'
 
 class hgbuildext(build_ext):
     user_options = build_ext.user_options + [
         ('zstd', None, 'compile zstd bindings [default]'),
         ('no-zstd', None, 'do not compile zstd bindings'),
     ]
 
     boolean_options = build_ext.boolean_options + ['zstd']
     negative_opt = buildextnegops
 
     def initialize_options(self):
         self.zstd = True
         return build_ext.initialize_options(self)
 
     def build_extensions(self):
         # Filter out zstd if disabled via argument.
         if not self.zstd:
             self.extensions = [e for e in self.extensions
                                if e.name != 'mercurial.zstd']
 
         return build_ext.build_extensions(self)
 
     def build_extension(self, ext):
         try:
             build_ext.build_extension(self, ext)
         except CCompilerError:
             if not getattr(ext, 'optional', False):
                 raise
             log.warn("Failed to build optional extension '%s' (skipping)",
                      ext.name)
 
 class hgbuildscripts(build_scripts):
     def run(self):
         if os.name != 'nt' or self.distribution.pure:
             return build_scripts.run(self)
 
         exebuilt = False
         try:
             self.run_command('build_hgexe')
             exebuilt = True
         except (DistutilsError, CCompilerError):
             log.warn('failed to build optional hg.exe')
 
         if exebuilt:
             # Copying hg.exe to the scripts build directory ensures it is
             # installed by the install_scripts command.
             hgexecommand = self.get_finalized_command('build_hgexe')
             dest = os.path.join(self.build_dir, 'hg.exe')
             self.mkpath(self.build_dir)
             self.copy_file(hgexecommand.hgexepath, dest)
 
             # Remove hg.bat because it is redundant with hg.exe.
             self.scripts.remove('contrib/win32/hg.bat')
 
         return build_scripts.run(self)
 
 class hgbuildpy(build_py):
     def finalize_options(self):
         build_py.finalize_options(self)
 
         if self.distribution.pure:
             self.distribution.ext_modules = []
         elif self.distribution.cffi:
             from mercurial.cffi import (
                 bdiffbuild,
                 mpatchbuild,
             )
             exts = [mpatchbuild.ffi.distutils_extension(),
                     bdiffbuild.ffi.distutils_extension()]
             # cffi modules go here
             if sys.platform == 'darwin':
                 from mercurial.cffi import osutilbuild
                 exts.append(osutilbuild.ffi.distutils_extension())
             self.distribution.ext_modules = exts
         else:
             h = os.path.join(get_python_inc(), 'Python.h')
             if not os.path.exists(h):
                 raise SystemExit('Python headers are required to build '
                                  'Mercurial but weren\'t found in %s' % h)
 
     def run(self):
         basepath = os.path.join(self.build_lib, 'mercurial')
         self.mkpath(basepath)
 
         if self.distribution.pure:
             modulepolicy = 'py'
         elif self.build_lib == '.':
             # in-place build should run without rebuilding C extensions
             modulepolicy = 'allow'
         else:
             modulepolicy = 'c'
 
         content = b''.join([
             b'# this file is autogenerated by setup.py\n',
             b'modulepolicy = b"%s"\n' % modulepolicy.encode('ascii'),
         ])
         write_if_changed(os.path.join(basepath, '__modulepolicy__.py'),
                          content)
 
         build_py.run(self)
 
 class buildhgextindex(Command):
     description = 'generate prebuilt index of hgext (for frozen package)'
     user_options = []
     _indexfilename = 'hgext/__index__.py'
 
     def initialize_options(self):
         pass
 
     def finalize_options(self):
         pass
 
     def run(self):
         if os.path.exists(self._indexfilename):
             with open(self._indexfilename, 'w') as f:
                 f.write('# empty\n')
 
         # here no extension enabled, disabled() lists up everything
         code = ('import pprint; from mercurial import extensions; '
                 'pprint.pprint(extensions.disabled())')
         returncode, out, err = runcmd([sys.executable, '-c', code],
                                       localhgenv())
         if err or returncode != 0:
             raise DistutilsExecError(err)
 
         with open(self._indexfilename, 'w') as f:
             f.write('# this file is autogenerated by setup.py\n')
             f.write('docs = ')
             f.write(out)
 
 class buildhgexe(build_ext):
     description = 'compile hg.exe from mercurial/exewrapper.c'
     user_options = build_ext.user_options + [
         ('long-paths-support', None, 'enable support for long paths on '
                                      'Windows (off by default and '
                                      'experimental)'),
     ]
 
     LONG_PATHS_MANIFEST = """
     <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
     <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
         <application>
             <windowsSettings
             xmlns:ws2="http://schemas.microsoft.com/SMI/2016/WindowsSettings">
                 <ws2:longPathAware>true</ws2:longPathAware>
             </windowsSettings>
         </application>
     </assembly>"""
 
     def initialize_options(self):
         build_ext.initialize_options(self)
         self.long_paths_support = False
 
     def build_extensions(self):
         if os.name != 'nt':
             return
         if isinstance(self.compiler, HackedMingw32CCompiler):
             self.compiler.compiler_so = self.compiler.compiler # no -mdll
             self.compiler.dll_libraries = [] # no -lmsrvc90
 
         # Different Python installs can have different Python library
         # names. e.g. the official CPython distribution uses pythonXY.dll
         # and MinGW uses libpythonX.Y.dll.
         _kernel32 = ctypes.windll.kernel32
         _kernel32.GetModuleFileNameA.argtypes = [ctypes.c_void_p,
                                                  ctypes.c_void_p,
                                                  ctypes.c_ulong]
         _kernel32.GetModuleFileNameA.restype = ctypes.c_ulong
         size = 1000
         buf = ctypes.create_string_buffer(size + 1)
         filelen = _kernel32.GetModuleFileNameA(sys.dllhandle, ctypes.byref(buf),
                                                size)
 
         if filelen > 0 and filelen != size:
             dllbasename = os.path.basename(buf.value)
             if not dllbasename.lower().endswith('.dll'):
                 raise SystemExit('Python DLL does not end with .dll: %s' %
                                  dllbasename)
             pythonlib = dllbasename[:-4]
         else:
             log.warn('could not determine Python DLL filename; '
                      'assuming pythonXY')
 
             hv = sys.hexversion
             pythonlib = 'python%d%d' % (hv >> 24, (hv >> 16) & 0xff)
 
         log.info('using %s as Python library name' % pythonlib)
         with open('mercurial/hgpythonlib.h', 'wb') as f:
             f.write('/* this file is autogenerated by setup.py */\n')
             f.write('#define HGPYTHONLIB "%s"\n' % pythonlib)
         objects = self.compiler.compile(['mercurial/exewrapper.c'],
                                          output_dir=self.build_temp)
         dir = os.path.dirname(self.get_ext_fullpath('dummy'))
         self.hgtarget = os.path.join(dir, 'hg')
         self.compiler.link_executable(objects, self.hgtarget,
                                       libraries=[],
                                       output_dir=self.build_temp)
         if self.long_paths_support:
             self.addlongpathsmanifest()
 
     def addlongpathsmanifest(self):
         """Add manifest pieces so that hg.exe understands long paths
 
         This is an EXPERIMENTAL feature, use with care.
         To enable long paths support, one needs to do two things:
         - build Mercurial with --long-paths-support option
         - change HKLM\SYSTEM\CurrentControlSet\Control\FileSystem\
                  LongPathsEnabled to have value 1.
 
         Please ignore 'warning 81010002: Unrecognized Element "longPathAware"';
         it happens because Mercurial uses mt.exe circa 2008, which is not
         yet aware of long paths support in the manifest (I think so at least).
         This does not stop mt.exe from embedding/merging the XML properly.
 
         Why resource #1 should be used for .exe manifests? I don't know and
         wasn't able to find an explanation for mortals. But it seems to work.
         """
         exefname = self.compiler.executable_filename(self.hgtarget)
         fdauto, manfname = tempfile.mkstemp(suffix='.hg.exe.manifest')
         os.close(fdauto)
         with open(manfname, 'w') as f:
             f.write(self.LONG_PATHS_MANIFEST)
         log.info("long paths manifest is written to '%s'" % manfname)
         inputresource = '-inputresource:%s;#1' % exefname
         outputresource = '-outputresource:%s;#1' % exefname
         log.info("running mt.exe to update hg.exe's manifest in-place")
         # supplying both -manifest and -inputresource to mt.exe makes
         # it merge the embedded and supplied manifests in the -outputresource
         self.spawn(['mt.exe', '-nologo', '-manifest', manfname,
                     inputresource, outputresource])
         log.info("done updating hg.exe's manifest")
         os.remove(manfname)
 
     @property
     def hgexepath(self):
         dir = os.path.dirname(self.get_ext_fullpath('dummy'))
         return os.path.join(self.build_temp, dir, 'hg.exe')
 
 class hginstall(install):
 
     user_options = install.user_options + [
         ('old-and-unmanageable', None,
          'noop, present for eggless setuptools compat'),
         ('single-version-externally-managed', None,
          'noop, present for eggless setuptools compat'),
     ]
 
     # Also helps setuptools not be sad while we refuse to create eggs.
     single_version_externally_managed = True
 
     def get_sub_commands(self):
         # Screen out egg related commands to prevent egg generation.  But allow
         # mercurial.egg-info generation, since that is part of modern
         # packaging.
         excl = set(['bdist_egg'])
         return filter(lambda x: x not in excl, install.get_sub_commands(self))
 
 class hginstalllib(install_lib):
     '''
     This is a specialization of install_lib that replaces the copy_file used
     there so that it supports setting the mode of files after copying them,
     instead of just preserving the mode that the files originally had.  If your
     system has a umask of something like 027, preserving the permissions when
     copying will lead to a broken install.
 
     Note that just passing keep_permissions=False to copy_file would be
     insufficient, as it might still be applying a umask.
     '''
 
     def run(self):
         realcopyfile = file_util.copy_file
         def copyfileandsetmode(*args, **kwargs):
             src, dst = args[0], args[1]
             dst, copied = realcopyfile(*args, **kwargs)
             if copied:
                 st = os.stat(src)
                 # Persist executable bit (apply it to group and other if user
                 # has it)
                 if st[stat.ST_MODE] & stat.S_IXUSR:
                     setmode = int('0755', 8)
                 else:
                     setmode = int('0644', 8)
                 m = stat.S_IMODE(st[stat.ST_MODE])
                 m = (m & ~int('0777', 8)) | setmode
                 os.chmod(dst, m)
         file_util.copy_file = copyfileandsetmode
         try:
             install_lib.run(self)
         finally:
             file_util.copy_file = realcopyfile
 
 class hginstallscripts(install_scripts):
     '''
     This is a specialization of install_scripts that replaces the @LIBDIR@ with
     the configured directory for modules. If possible, the path is made relative
     to the directory for scripts.
     '''
 
     def initialize_options(self):
         install_scripts.initialize_options(self)
 
         self.install_lib = None
 
     def finalize_options(self):
         install_scripts.finalize_options(self)
         self.set_undefined_options('install',
                                    ('install_lib', 'install_lib'))
 
     def run(self):
         install_scripts.run(self)
 
         # It only makes sense to replace @LIBDIR@ with the install path if
         # the install path is known. For wheels, the logic below calculates
         # the libdir to be "../..". This is because the internal layout of a
         # wheel archive looks like:
         #
         #   mercurial-3.6.1.data/scripts/hg
         #   mercurial/__init__.py
         #
         # When installing wheels, the subdirectories of the "<pkg>.data"
         # directory are translated to system local paths and files therein
         # are copied in place. The mercurial/* files are installed into the
         # site-packages directory. However, the site-packages directory
         # isn't known until wheel install time. This means we have no clue
         # at wheel generation time what the installed site-packages directory
         # will be. And, wheels don't appear to provide the ability to register
         # custom code to run during wheel installation. This all means that
         # we can't reliably set the libdir in wheels: the default behavior
         # of looking in sys.path must do.
 
         if (os.path.splitdrive(self.install_dir)[0] !=
             os.path.splitdrive(self.install_lib)[0]):
             # can't make relative paths from one drive to another, so use an
             # absolute path instead
             libdir = self.install_lib
         else:
             common = os.path.commonprefix((self.install_dir, self.install_lib))
             rest = self.install_dir[len(common):]
             uplevel = len([n for n in os.path.split(rest) if n])
 
             libdir = uplevel * ('..' + os.sep) + self.install_lib[len(common):]
 
         for outfile in self.outfiles:
             with open(outfile, 'rb') as fp:
                 data = fp.read()
 
             # skip binary files
             if b'\0' in data:
                 continue
 
             # During local installs, the shebang will be rewritten to the final
             # install path. During wheel packaging, the shebang has a special
             # value.
             if data.startswith(b'#!python'):
                 log.info('not rewriting @LIBDIR@ in %s because install path '
                          'not known' % outfile)
                 continue
 
             data = data.replace(b'@LIBDIR@', libdir.encode(libdir_escape))
             with open(outfile, 'wb') as fp:
                 fp.write(data)
 
 cmdclass = {'build': hgbuild,
             'build_mo': hgbuildmo,
             'build_ext': hgbuildext,
             'build_py': hgbuildpy,
             'build_scripts': hgbuildscripts,
             'build_hgextindex': buildhgextindex,
             'install': hginstall,
             'install_lib': hginstalllib,
             'install_scripts': hginstallscripts,
             'build_hgexe': buildhgexe,
             }
 
 packages = ['mercurial',
             'mercurial.cext',
             'mercurial.cffi',
             'mercurial.hgweb',
             'mercurial.pure',
             'mercurial.thirdparty',
             'mercurial.thirdparty.attr',
             'mercurial.utils',
             'hgext', 'hgext.convert', 'hgext.fsmonitor',
             'hgext.fsmonitor.pywatchman', 'hgext.highlight',
             'hgext.largefiles', 'hgext.lfs', 'hgext.narrow',
             'hgext.zeroconf', 'hgext3rd',
             'hgdemandimport']
 
 common_depends = ['mercurial/bitmanipulation.h',
                   'mercurial/compat.h',
                   'mercurial/cext/util.h']
 common_include_dirs = ['mercurial']
 
 osutil_cflags = []
 osutil_ldflags = []
 
 # platform specific macros
 for plat, func in [('bsd', 'setproctitle')]:
     if re.search(plat, sys.platform) and hasfunction(new_compiler(), func):
         osutil_cflags.append('-DHAVE_%s' % func.upper())
 
 for plat, macro, code in [
     ('bsd|darwin', 'BSD_STATFS', '''
      #include <sys/param.h>
      #include <sys/mount.h>
      int main() { struct statfs s; return sizeof(s.f_fstypename); }
      '''),
     ('linux', 'LINUX_STATFS', '''
      #include <linux/magic.h>
      #include <sys/vfs.h>
      int main() { struct statfs s; return sizeof(s.f_type); }
      '''),
 ]:
     if re.search(plat, sys.platform) and cancompile(new_compiler(), code):
         osutil_cflags.append('-DHAVE_%s' % macro)
 
 if sys.platform == 'darwin':
     osutil_ldflags += ['-framework', 'ApplicationServices']
 
 xdiff_srcs = [
     'mercurial/thirdparty/xdiff/xdiffi.c',
-    'mercurial/thirdparty/xdiff/xemit.c',
     'mercurial/thirdparty/xdiff/xmerge.c',
     'mercurial/thirdparty/xdiff/xprepare.c',
     'mercurial/thirdparty/xdiff/xutils.c',
 ]
 
 xdiff_headers = [
     'mercurial/thirdparty/xdiff/xdiff.h',
     'mercurial/thirdparty/xdiff/xdiffi.h',
-    'mercurial/thirdparty/xdiff/xemit.h',
     'mercurial/thirdparty/xdiff/xinclude.h',
     'mercurial/thirdparty/xdiff/xmacros.h',
     'mercurial/thirdparty/xdiff/xprepare.h',
     'mercurial/thirdparty/xdiff/xtypes.h',
     'mercurial/thirdparty/xdiff/xutils.h',
 ]
 
 extmodules = [
     Extension('mercurial.cext.base85', ['mercurial/cext/base85.c'],
               include_dirs=common_include_dirs,
               depends=common_depends),
     Extension('mercurial.cext.bdiff', ['mercurial/bdiff.c',
                                        'mercurial/cext/bdiff.c'] + xdiff_srcs,
               include_dirs=common_include_dirs,
               depends=common_depends + ['mercurial/bdiff.h'] + xdiff_headers),
     Extension('mercurial.cext.diffhelpers', ['mercurial/cext/diffhelpers.c'],
               include_dirs=common_include_dirs,
               depends=common_depends),
     Extension('mercurial.cext.mpatch', ['mercurial/mpatch.c',
                                         'mercurial/cext/mpatch.c'],
               include_dirs=common_include_dirs,
               depends=common_depends),
     Extension('mercurial.cext.parsers', ['mercurial/cext/charencode.c',
                                          'mercurial/cext/dirs.c',
                                          'mercurial/cext/manifest.c',
                                          'mercurial/cext/parsers.c',
                                          'mercurial/cext/pathencode.c',
                                          'mercurial/cext/revlog.c'],
               include_dirs=common_include_dirs,
               depends=common_depends + ['mercurial/cext/charencode.h']),
     Extension('mercurial.cext.osutil', ['mercurial/cext/osutil.c'],
               include_dirs=common_include_dirs,
               extra_compile_args=osutil_cflags,
               extra_link_args=osutil_ldflags,
               depends=common_depends),
     Extension('hgext.fsmonitor.pywatchman.bser',
               ['hgext/fsmonitor/pywatchman/bser.c']),
     ]
 
 sys.path.insert(0, 'contrib/python-zstandard')
 import setup_zstd
 extmodules.append(setup_zstd.get_c_extension(name='mercurial.zstd'))
 
 try:
     from distutils import cygwinccompiler
 
     # the -mno-cygwin option has been deprecated for years
     mingw32compilerclass = cygwinccompiler.Mingw32CCompiler
 
     class HackedMingw32CCompiler(cygwinccompiler.Mingw32CCompiler):
         def __init__(self, *args, **kwargs):
             mingw32compilerclass.__init__(self, *args, **kwargs)
             for i in 'compiler compiler_so linker_exe linker_so'.split():
                 try:
                     getattr(self, i).remove('-mno-cygwin')
                 except ValueError:
                     pass
 
     cygwinccompiler.Mingw32CCompiler = HackedMingw32CCompiler
 except ImportError:
     # the cygwinccompiler package is not available on some Python
     # distributions like the ones from the optware project for Synology
     # DiskStation boxes
     class HackedMingw32CCompiler(object):
         pass
 
 if os.name == 'nt':
     # Allow compiler/linker flags to be added to Visual Studio builds.  Passing
     # extra_link_args to distutils.extensions.Extension() doesn't have any
     # effect.
     from distutils import msvccompiler
 
     msvccompilerclass = msvccompiler.MSVCCompiler
 
     class HackedMSVCCompiler(msvccompiler.MSVCCompiler):
         def initialize(self):
             msvccompilerclass.initialize(self)
             # "warning LNK4197: export 'func' specified multiple times"
             self.ldflags_shared.append('/ignore:4197')
             self.ldflags_shared_debug.append('/ignore:4197')
 
     msvccompiler.MSVCCompiler = HackedMSVCCompiler
 
 packagedata = {'mercurial': ['locale/*/LC_MESSAGES/hg.mo',
                              'help/*.txt',
                              'help/internals/*.txt',
                              'default.d/*.rc',
                              'dummycert.pem']}
 
 def ordinarypath(p):
     return p and p[0] != '.' and p[-1] != '~'
 
 for root in ('templates',):
     for curdir, dirs, files in os.walk(os.path.join('mercurial', root)):
         curdir = curdir.split(os.sep, 1)[1]
         dirs[:] = filter(ordinarypath, dirs)
         for f in filter(ordinarypath, files):
             f = os.path.join(curdir, f)
             packagedata['mercurial'].append(f)
 
 datafiles = []
 
 # distutils expects version to be str/unicode. Converting it to
 # unicode on Python 2 still works because it won't contain any
 # non-ascii bytes and will be implicitly converted back to bytes
 # when operated on.
 assert isinstance(version, bytes)
 setupversion = version.decode('ascii')
 
 extra = {}
 
 if issetuptools:
     extra['python_requires'] = supportedpy
 if py2exeloaded:
     extra['console'] = [
         {'script':'hg',
          'copyright':'Copyright (C) 2005-2018 Matt Mackall and others',
          'product_version':version}]
     # sub command of 'build' because 'py2exe' does not handle sub_commands
     build.sub_commands.insert(0, ('build_hgextindex', None))
     # put dlls in sub directory so that they won't pollute PATH
     extra['zipfile'] = 'lib/library.zip'
 
 if os.name == 'nt':
     # Windows binary file versions for exe/dll files must have the
     # form W.X.Y.Z, where W,X,Y,Z are numbers in the range 0..65535
     setupversion = version.split('+', 1)[0]
 
 if sys.platform == 'darwin' and os.path.exists('/usr/bin/xcodebuild'):
     version = runcmd(['/usr/bin/xcodebuild', '-version'], {})[1].splitlines()
     if version:
         version = version[0]
         if sys.version_info[0] == 3:
             version = version.decode('utf-8')
         xcode4 = (version.startswith('Xcode') and
                   StrictVersion(version.split()[1]) >= StrictVersion('4.0'))
         xcode51 = re.match(r'^Xcode\s+5\.1', version) is not None
     else:
         # xcodebuild returns empty on OS X Lion with XCode 4.3 not
         # installed, but instead with only command-line tools. Assume
         # that only happens on >= Lion, thus no PPC support.
         xcode4 = True
         xcode51 = False
 
     # XCode 4.0 dropped support for ppc architecture, which is hardcoded in
     # distutils.sysconfig
     if xcode4:
         os.environ['ARCHFLAGS'] = ''
 
     # XCode 5.1 changes clang such that it now fails to compile if the
     # -mno-fused-madd flag is passed, but the version of Python shipped with
     # OS X 10.9 Mavericks includes this flag. This causes problems in all
     # C extension modules, and a bug has been filed upstream at
     # http://bugs.python.org/issue21244. We also need to patch this here
     # so Mercurial can continue to compile in the meantime.
     if xcode51:
         cflags = get_config_var('CFLAGS')
         if cflags and re.search(r'-mno-fused-madd\b', cflags) is not None:
             os.environ['CFLAGS'] = (
                 os.environ.get('CFLAGS', '') + ' -Qunused-arguments')
 
 setup(name='mercurial',
       version=setupversion,
       author='Matt Mackall and many others',
       author_email='[e-mail]',
       url='https://mercurial-scm.org/',
       download_url='https://mercurial-scm.org/release/',
       description=('Fast scalable distributed SCM (revision control, version '
                    'control) system'),
       long_description=('Mercurial is a distributed SCM tool written in Python.'
                         ' It is used by a number of large projects that require'
                         ' fast, reliable distributed revision control, such as '
                         'Mozilla.'),
       license='GNU GPLv2 or any later version',
       classifiers=[
           'Development Status :: 6 - Mature',
           'Environment :: Console',
           'Intended Audience :: Developers',
           'Intended Audience :: System Administrators',
           'License :: OSI Approved :: GNU General Public License (GPL)',
           'Natural Language :: Danish',
           'Natural Language :: English',
           'Natural Language :: German',
           'Natural Language :: Italian',
           'Natural Language :: Japanese',
           'Natural Language :: Portuguese (Brazilian)',
           'Operating System :: Microsoft :: Windows',
           'Operating System :: OS Independent',
           'Operating System :: POSIX',
           'Programming Language :: C',
           'Programming Language :: Python',
           'Topic :: Software Development :: Version Control',
       ],
       scripts=scripts,
       packages=packages,
       ext_modules=extmodules,
       data_files=datafiles,
       package_data=packagedata,
       cmdclass=cmdclass,
       distclass=hgdist,
       options={'py2exe': {'packages': ['hgdemandimport', 'hgext', 'email',
                                        # implicitly imported per module policy
                                        # (cffi wouldn't be used as a frozen exe)
                                        'mercurial.cext',
                                        #'mercurial.cffi',
                                        'mercurial.pure']},
                'bdist_mpkg': {'zipdist': False,
                               'license': 'COPYING',
                               'readme': 'contrib/macosx/Readme.html',
                               'welcome': 'contrib/macosx/Welcome.html',
                               },
                },
       **extra)