xdiff: remove unused structure, functions, and constants

`bdiffparam_t` is unused. `xdl_fall_back_diff` is no longer used after
D2573.  `XDL_MMB_READONLY`, `XDL_MMF_ATOMIC` are unused. `XDL_BDOP*` are
unused since there is no xdiff binary diff algorithm. `anchors` feature is
not used. It's also relatively new in git.

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

mercurial/cext/bdiff.c

@@ -1,352 +1,350 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 */
-	    NULL,                 /* anchors */
-	    0,                    /* anchors_nr */
 	};
 	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,139 +1,123 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)
 
-#define XDL_MMB_READONLY (1 << 0)
-
-#define XDL_MMF_ATOMIC (1 << 0)
-
-#define XDL_BDOP_INS 1
-#define XDL_BDOP_CPY 2
-#define XDL_BDOP_INSB 3
-
 /* 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;
-
-	/* See Documentation/diff-options.txt. */
-	char **anchors;
-	size_t anchors_nr;
 } 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;
 
-typedef struct s_bdiffparam {
-	long bsize;
-} bdiffparam_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.h

@@ -1,64 +1,60 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);
-int xdl_do_patience_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
-		xdfenv_t *env);
-int xdl_do_histogram_diff(mmfile_t *mf1, mmfile_t *mf2, xpparam_t const *xpp,
-		xdfenv_t *env);
 
 #endif /* #if !defined(XDIFFI_H) */

mercurial/thirdparty/xdiff/xutils.c

@@ -1,274 +1,243 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;
 }
-
-int xdl_fall_back_diff(xdfenv_t *diff_env, xpparam_t const *xpp,
-		int line1, int count1, int line2, int count2)
-{
-	/*
-	 * This probably does not work outside Git, since
-	 * we have a very simple mmfile structure.
-	 *
-	 * Note: ideally, we would reuse the prepared environment, but
-	 * the libxdiff interface does not (yet) allow for diffing only
-	 * ranges of lines instead of the whole files.
-	 */
-	mmfile_t subfile1, subfile2;
-	xdfenv_t env;
-
-	subfile1.ptr = (char *)diff_env->xdf1.recs[line1 - 1]->ptr;
-	subfile1.size = diff_env->xdf1.recs[line1 + count1 - 2]->ptr +
-		diff_env->xdf1.recs[line1 + count1 - 2]->size - subfile1.ptr;
-	subfile2.ptr = (char *)diff_env->xdf2.recs[line2 - 1]->ptr;
-	subfile2.size = diff_env->xdf2.recs[line2 + count2 - 2]->ptr +
-		diff_env->xdf2.recs[line2 + count2 - 2]->size - subfile2.ptr;
-	if (xdl_do_diff(&subfile1, &subfile2, xpp, &env) < 0)
-		return -1;
-
-	memcpy(diff_env->xdf1.rchg + line1 - 1, env.xdf1.rchg, count1);
-	memcpy(diff_env->xdf2.rchg + line2 - 1, env.xdf2.rchg, count2);
-
-	xdl_free_env(&env);
-
-	return 0;
-}

mercurial/thirdparty/xdiff/xutils.h

@@ -1,46 +1,44 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);
-int xdl_fall_back_diff(xdfenv_t *diff_env, xpparam_t const *xpp,
-		       int line1, int count1, int line2, int count2);
 
 
 
 #endif /* #if !defined(XUTILS_H) */