This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2683

xdiff: remove whitespace related feature
ClosedPublic

Authored by quark on Mar 4 2018, 7:50 PM.

Download Raw Diff

Details

Reviewers

indygreg

Group Reviewers

hg-reviewers

Commits

rHG09f320067591: xdiff: remove whitespace related feature

Summary

In Mercurial, whitespace related handling are done at a higher level than
the low-level diff algorithm so "ignore spaces". So it's not used by mdiff.
Some of the upcoming optimizations would be more difficult with whitespace
related features kept. So let's remove them.

Diff Detail

Repository

rHG Mercurial

Lint

Automatic diff as part of commit; lint not applicable.

Unit

Automatic diff as part of commit; unit tests not applicable.

Event Timeline

quark created this revision.Mar 4 2018, 7:50 PM

Herald added a reviewer: hg-reviewers. · View Herald TranscriptMar 4 2018, 7:50 PM

Herald added a subscriber: mercurial-devel. · View Herald Transcript

quark added a child revision: D2684: xdiff: remove unused structure, functions, and constants.Mar 4 2018, 7:50 PM

quark abandoned this revision.Mar 4 2018, 8:09 PM

quark updated this revision to Diff 6681.Mar 6 2018, 9:52 PM

I *love* patches that only remove code.

This revision is now accepted and ready to land.Mar 6 2018, 10:06 PM

Closed by commit rHG09f320067591: xdiff: remove whitespace related feature (authored by quark). · Explain WhyMar 6 2018, 10:11 PM

This revision was automatically updated to reflect the committed changes.

quark mentioned this in D2763: xdiff: remove unused flags parameter.Mar 9 2018, 5:54 PM

quark mentioned this in rHG4c8ffc67bac2: xdiff: remove unused flags parameter.Mar 9 2018, 6:24 PM

quark mentioned this in rHG49fe6249937a: xdiff: remove unused flags parameter.Mar 10 2018, 1:21 PM

Revision Contents
Changeset List

			Path	Packages
M			mercurial/thirdparty/xdiff/xdiff.h (11 lines)
M			mercurial/thirdparty/xdiff/xdiffi.c (23 lines)
M			mercurial/thirdparty/xdiff/xutils.h (1 line)
M			mercurial/thirdparty/xdiff/xutils.c (153 lines)

Diff	ID	Description	Created	Lint	Unit
Base		Base
Diff 1	6641		Mar 4 2018, 7:50 PM	★	★
Diff 2	6681		Mar 6 2018, 9:52 PM	★	★
Diff 3	6685	rHG09f32006759122df8ca4fc4730d2f1acbb3965ae	Mar 4 2018, 3:07 AM	★	★

Status	Author	Revision
Closed	quark	D2706 xdiff: remove xmerge related logic
Closed	quark	D2705 xdiff: remove xemit related logic
Closed	quark	D2684 xdiff: remove unused structure, functions, and constants
Closed	quark	D2683 xdiff: remove whitespace related feature

Diff 6685

mercurial/thirdparty/xdiff/xdiff.h

	extern "C" {			extern "C" {
	#endif /* #ifdef __cplusplus */			#endif /* #ifdef __cplusplus */

	#include <stddef.h> /* size_t */			#include <stddef.h> /* size_t */

	/* xpparm_t.flags */			/* xpparm_t.flags */
	#define XDF_NEED_MINIMAL (1 << 0)			#define XDF_NEED_MINIMAL (1 << 0)

	#define XDF_IGNORE_WHITESPACE (1 << 1)
	#define XDF_IGNORE_WHITESPACE_CHANGE (1 << 2)
	#define XDF_IGNORE_WHITESPACE_AT_EOL (1 << 3)
	#define XDF_IGNORE_CR_AT_EOL (1 << 4)
	#define XDF_WHITESPACE_FLAGS (XDF_IGNORE_WHITESPACE \| \
	XDF_IGNORE_WHITESPACE_CHANGE \| \
	XDF_IGNORE_WHITESPACE_AT_EOL \| \
	XDF_IGNORE_CR_AT_EOL)

	#define XDF_IGNORE_BLANK_LINES (1 << 7)

	#define XDF_INDENT_HEURISTIC (1 << 23)			#define XDF_INDENT_HEURISTIC (1 << 23)

	/* xdemitconf_t.flags */			/* xdemitconf_t.flags */
	#define XDL_EMIT_FUNCNAMES (1 << 0)			#define XDL_EMIT_FUNCNAMES (1 << 0)
	#define XDL_EMIT_FUNCCONTEXT (1 << 2)			#define XDL_EMIT_FUNCCONTEXT (1 << 2)
	/* emit bdiff-style "matched" (a1, a2, b1, b2) hunks instead of "different"			/* emit bdiff-style "matched" (a1, a2, b1, b2) hunks instead of "different"
	* (a1, a2 - a1, b1, b2 - b1) hunks */			* (a1, a2 - a1, b1, b2 - b1) hunks */
	#define XDL_EMIT_BDIFFHUNK (1 << 4)			#define XDL_EMIT_BDIFFHUNK (1 << 4)

mercurial/thirdparty/xdiff/xdiffi.c

	xch->i2, xche->i2 + xche->chg2 - xch->i2,			xch->i2, xche->i2 + xche->chg2 - xch->i2,
	ecb->priv) < 0)			ecb->priv) < 0)
	return -1;			return -1;
	}			}
	}			}
	return 0;			return 0;
	}			}

	static void xdl_mark_ignorable(xdchange_t xscr, xdfenv_t xe, long flags)
	{
	xdchange_t *xch;

	for (xch = xscr; xch; xch = xch->next) {
	int ignore = 1;
	xrecord_t **rec;
	long i;

	rec = &xe->xdf1.recs[xch->i1];
	for (i = 0; i < xch->chg1 && ignore; i++)
	ignore = xdl_blankline(rec[i]->ptr, rec[i]->size, flags);

	rec = &xe->xdf2.recs[xch->i2];
	for (i = 0; i < xch->chg2 && ignore; i++)
	ignore = xdl_blankline(rec[i]->ptr, rec[i]->size, flags);

	xch->ignore = ignore;
	}
	}

	int xdl_diff(mmfile_t mf1, mmfile_t mf2, xpparam_t const *xpp,			int xdl_diff(mmfile_t mf1, mmfile_t mf2, xpparam_t const *xpp,
	xdemitconf_t const xecfg, xdemitcb_t ecb) {			xdemitconf_t const xecfg, xdemitcb_t ecb) {
	xdchange_t *xscr;			xdchange_t *xscr;
	xdfenv_t xe;			xdfenv_t xe;
	emit_func_t ef = xecfg->hunk_func ? xdl_call_hunk_func : xdl_emit_diff;			emit_func_t ef = xecfg->hunk_func ? xdl_call_hunk_func : xdl_emit_diff;

	if (xdl_do_diff(mf1, mf2, xpp, &xe) < 0) {			if (xdl_do_diff(mf1, mf2, xpp, &xe) < 0) {

	return -1;			return -1;
	}			}
	if (xdl_change_compact(&xe.xdf1, &xe.xdf2, xpp->flags) < 0 \|\|			if (xdl_change_compact(&xe.xdf1, &xe.xdf2, xpp->flags) < 0 \|\|
	xdl_change_compact(&xe.xdf2, &xe.xdf1, xpp->flags) < 0 \|\|			xdl_change_compact(&xe.xdf2, &xe.xdf1, xpp->flags) < 0 \|\|
	xdl_build_script(&xe, &xscr) < 0) {			xdl_build_script(&xe, &xscr) < 0) {

	xdl_free_env(&xe);			xdl_free_env(&xe);
	return -1;			return -1;
	}			}

	if (xpp->flags & XDF_IGNORE_BLANK_LINES)
	xdl_mark_ignorable(xscr, &xe, xpp->flags);
	if (ef(&xe, xscr, ecb, xecfg) < 0) {			if (ef(&xe, xscr, ecb, xecfg) < 0) {
	xdl_free_script(xscr);			xdl_free_script(xscr);
	xdl_free_env(&xe);			xdl_free_env(&xe);
	return -1;			return -1;
	}			}
	xdl_free_script(xscr);			xdl_free_script(xscr);
	xdl_free_env(&xe);			xdl_free_env(&xe);

	return 0;			return 0;
	}			}

mercurial/thirdparty/xdiff/xutils.h


	long xdl_bogosqrt(long n);			long xdl_bogosqrt(long n);
	int xdl_emit_diffrec(char const rec, long size, char const pre, long psize,			int xdl_emit_diffrec(char const rec, long size, char const pre, long psize,
	xdemitcb_t *ecb);			xdemitcb_t *ecb);
	int xdl_cha_init(chastore_t *cha, long isize, long icount);			int xdl_cha_init(chastore_t *cha, long isize, long icount);
	void xdl_cha_free(chastore_t *cha);			void xdl_cha_free(chastore_t *cha);
	void xdl_cha_alloc(chastore_t cha);			void xdl_cha_alloc(chastore_t cha);
	long xdl_guess_lines(mmfile_t *mf, long sample);			long xdl_guess_lines(mmfile_t *mf, long sample);
	int xdl_blankline(const char *line, long size, long flags);
	int xdl_recmatch(const char l1, long s1, const char l2, long s2, long flags);			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 long xdl_hash_record(char const *data, char const top, long flags);
	unsigned int xdl_hashbits(unsigned int size);			unsigned int xdl_hashbits(unsigned int size);
	int xdl_num_out(char *out, long val);			int xdl_num_out(char *out, long val);
	int xdl_emit_hunk_hdr(long s1, long c1, long s2, long c2,			int xdl_emit_hunk_hdr(long s1, long c1, long s2, long c2,
	const char func, long funclen, xdemitcb_t ecb);			const char func, long funclen, xdemitcb_t ecb);
	int xdl_fall_back_diff(xdfenv_t diff_env, xpparam_t const xpp,			int xdl_fall_back_diff(xdfenv_t diff_env, xpparam_t const xpp,
	int line1, int count1, int line2, int count2);			int line1, int count1, int line2, int count2);



	#endif /* #if !defined(XUTILS_H) */			#endif /* #if !defined(XUTILS_H) */

mercurial/thirdparty/xdiff/xutils.c

	}			}

	if (nl && tsize)			if (nl && tsize)
	nl = xdl_mmfile_size(mf) / (tsize / nl);			nl = xdl_mmfile_size(mf) / (tsize / nl);

	return nl + 1;			return nl + 1;
	}			}

	int xdl_blankline(const char *line, long size, long flags)
	{
	long i;

	if (!(flags & XDF_WHITESPACE_FLAGS))
	return (size <= 1);

	for (i = 0; i < size && XDL_ISSPACE(line[i]); i++)
	;

	return (i == size);
	}

	/*
	* Have we eaten everything on the line, except for an optional
	* CR at the very end?
	*/
	static int ends_with_optional_cr(const char *l, long s, long i)
	{
	int complete = s && l[s-1] == '\n';

	if (complete)
	s--;
	if (s == i)
	return 1;
	/* do not ignore CR at the end of an incomplete line */
	if (complete && s == i + 1 && l[i] == '\r')
	return 1;
	return 0;
	}

	int xdl_recmatch(const char l1, long s1, const char l2, long s2, long flags)			int xdl_recmatch(const char l1, long s1, const char l2, long s2, long flags)
	{			{
	int i1, i2;

	if (s1 == s2 && !memcmp(l1, l2, s1))			if (s1 == s2 && !memcmp(l1, l2, s1))
	return 1;			return 1;
	if (!(flags & XDF_WHITESPACE_FLAGS))
	return 0;

	i1 = 0;
	i2 = 0;

	/*
	* -w matches everything that matches with -b, and -b in turn
	* matches everything that matches with --ignore-space-at-eol,
	* which in turn matches everything that matches with --ignore-cr-at-eol.
	*
	* Each flavor of ignoring needs different logic to skip whitespaces
	* while we have both sides to compare.
	*/
	if (flags & XDF_IGNORE_WHITESPACE) {
	goto skip_ws;
	while (i1 < s1 && i2 < s2) {
	if (l1[i1++] != l2[i2++])
	return 0;
	skip_ws:
	while (i1 < s1 && XDL_ISSPACE(l1[i1]))
	i1++;
	while (i2 < s2 && XDL_ISSPACE(l2[i2]))
	i2++;
	}
	} else if (flags & XDF_IGNORE_WHITESPACE_CHANGE) {
	while (i1 < s1 && i2 < s2) {
	if (XDL_ISSPACE(l1[i1]) && XDL_ISSPACE(l2[i2])) {
	/* Skip matching spaces and try again */
	while (i1 < s1 && XDL_ISSPACE(l1[i1]))
	i1++;
	while (i2 < s2 && XDL_ISSPACE(l2[i2]))
	i2++;
	continue;
	}
	if (l1[i1++] != l2[i2++])
	return 0;
	}
	} else if (flags & XDF_IGNORE_WHITESPACE_AT_EOL) {
	while (i1 < s1 && i2 < s2 && l1[i1] == l2[i2]) {
	i1++;
	i2++;
	}
	} else if (flags & XDF_IGNORE_CR_AT_EOL) {
	/* Find the first difference and see how the line ends */
	while (i1 < s1 && i2 < s2 && l1[i1] == l2[i2]) {
	i1++;
	i2++;
	}
	return (ends_with_optional_cr(l1, s1, i1) &&
	ends_with_optional_cr(l2, s2, i2));
	}

	/*
	* After running out of one side, the remaining side must have
	* nothing but whitespace for the lines to match. Note that
	* ignore-whitespace-at-eol case may break out of the loop
	* while there still are characters remaining on both lines.
	*/
	if (i1 < s1) {
	while (i1 < s1 && XDL_ISSPACE(l1[i1]))
	i1++;
	if (s1 != i1)
	return 0;			return 0;
	}			}
	if (i2 < s2) {
	while (i2 < s2 && XDL_ISSPACE(l2[i2]))
	i2++;
	return (s2 == i2);
	}
	return 1;
	}

	static unsigned long xdl_hash_record_with_whitespace(char const **data,
	char const *top, long flags) {
	unsigned long ha = 5381;
	char const ptr = data;
	int cr_at_eol_only = (flags & XDF_WHITESPACE_FLAGS) == XDF_IGNORE_CR_AT_EOL;

	for (; ptr < top && *ptr != '\n'; ptr++) {
	if (cr_at_eol_only) {
	/* do not ignore CR at the end of an incomplete line */
	if (*ptr == '\r' &&
	(ptr + 1 < top && ptr[1] == '\n'))
	continue;
	}
	else if (XDL_ISSPACE(*ptr)) {
	const char *ptr2 = ptr;
	int at_eol;
	while (ptr + 1 < top && XDL_ISSPACE(ptr[1])
	&& ptr[1] != '\n')
	ptr++;
	at_eol = (top <= ptr + 1 \|\| ptr[1] == '\n');
	if (flags & XDF_IGNORE_WHITESPACE)
	; /* already handled */
	else if (flags & XDF_IGNORE_WHITESPACE_CHANGE
	&& !at_eol) {
	ha += (ha << 5);
	ha ^= (unsigned long) ' ';
	}
	else if (flags & XDF_IGNORE_WHITESPACE_AT_EOL
	&& !at_eol) {
	while (ptr2 != ptr + 1) {
	ha += (ha << 5);
	ha ^= (unsigned long) *ptr2;
	ptr2++;
	}
	}
	continue;
	}
	ha += (ha << 5);
	ha ^= (unsigned long) *ptr;
	}
	*data = ptr < top ? ptr + 1: ptr;

	return ha;
	}

	unsigned long xdl_hash_record(char const *data, char const top, long flags) {			unsigned long xdl_hash_record(char const *data, char const top, long flags) {
	unsigned long ha = 5381;			unsigned long ha = 5381;
	char const ptr = data;			char const ptr = data;

	if (flags & XDF_WHITESPACE_FLAGS)
	return xdl_hash_record_with_whitespace(data, top, flags);

	for (; ptr < top && *ptr != '\n'; ptr++) {			for (; ptr < top && *ptr != '\n'; ptr++) {
	ha += (ha << 5);			ha += (ha << 5);
	ha ^= (unsigned long) *ptr;			ha ^= (unsigned long) *ptr;
	}			}
	*data = ptr < top ? ptr + 1: ptr;			*data = ptr < top ? ptr + 1: ptr;

	return ha;			return ha;
	}			}