This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2763

xdiff: remove unused flags parameter
ClosedPublic

Authored by quark on Mar 9 2018, 5:54 PM.

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHG49fe6249937a: xdiff: remove unused flags parameter
rHG4c8ffc67bac2: xdiff: remove unused flags parameter
Summary

After D2683, the flags parameter in some functions is no longer needed.
Thus removed.

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 9 2018, 5:54 PM
indygreg accepted this revision.Mar 9 2018, 6:20 PM
indygreg added a subscriber: indygreg.

Strictly speaking, we might want to bump the C extension version number because of the ABI change. But I'm not sure if these functions are exported or even used by our C extension. So it may not matter. It's an experimental feature right now, so I'm inclined to not care.

This revision is now accepted and ready to land.Mar 9 2018, 6:20 PM
Closed by commit rHG4c8ffc67bac2: xdiff: remove unused flags parameter (authored by quark). · Explain WhyMar 9 2018, 6:24 PM
This revision was automatically updated to reflect the committed changes.
quark added a comment.Mar 9 2018, 6:31 PM

I don't think the Python ".so"s should be consumed by non-Python "dlopen". So "version" doesn't change since Python API remains the same.

Revision Contents
Changeset List

Diff 6808

mercurial/thirdparty/xdiff/xdiffi.c

xch->chg1 = chg1; xch->chg1 = chg1;
xch->chg2 = chg2; xch->chg2 = chg2;
xch->ignore = 0; xch->ignore = 0;
return xch; return xch;
} }
static int recs_match(xrecord_t *rec1, xrecord_t *rec2, int64_t flags) static int recs_match(xrecord_t *rec1, xrecord_t *rec2)
{ {
return (rec1->ha == rec2->ha && return (rec1->ha == rec2->ha &&
xdl_recmatch(rec1->ptr, rec1->size, xdl_recmatch(rec1->ptr, rec1->size,
rec2->ptr, rec2->size, rec2->ptr, rec2->size));
flags));
} }
/* /*
* If a line is indented more than this, get_indent() just returns this value. * 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 * 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 * human-readable text, and also ensures that the output of get_indent fits within
* an int. * an int.
*/ */
return 0; return 0;
} }
/* /*
* If g can be slid toward the end of the file, do so, and if it bumps into a * 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 * following group, expand this group to include it. Return 0 on success or -1
* if g cannot be slid down. * if g cannot be slid down.
*/ */
static int group_slide_down(xdfile_t *xdf, struct xdlgroup *g, int64_t flags) static int group_slide_down(xdfile_t *xdf, struct xdlgroup *g)
{ {
if (g->end < xdf->nrec && if (g->end < xdf->nrec &&
recs_match(xdf->recs[g->start], xdf->recs[g->end], flags)) { recs_match(xdf->recs[g->start], xdf->recs[g->end])) {
xdf->rchg[g->start++] = 0; xdf->rchg[g->start++] = 0;
xdf->rchg[g->end++] = 1; xdf->rchg[g->end++] = 1;
while (xdf->rchg[g->end]) while (xdf->rchg[g->end])
g->end++; g->end++;
return 0; return 0;
} else { } else {
return -1; return -1;
} }
} }
/* /*
* If g can be slid toward the beginning of the file, do so, and if it bumps * 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 * into a previous group, expand this group to include it. Return 0 on success
* or -1 if g cannot be slid up. * or -1 if g cannot be slid up.
*/ */
static int group_slide_up(xdfile_t *xdf, struct xdlgroup *g, int64_t flags) static int group_slide_up(xdfile_t *xdf, struct xdlgroup *g)
{ {
if (g->start > 0 && if (g->start > 0 &&
recs_match(xdf->recs[g->start - 1], xdf->recs[g->end - 1], flags)) { recs_match(xdf->recs[g->start - 1], xdf->recs[g->end - 1])) {
xdf->rchg[--g->start] = 1; xdf->rchg[--g->start] = 1;
xdf->rchg[--g->end] = 0; xdf->rchg[--g->end] = 0;
while (xdf->rchg[g->start - 1]) while (xdf->rchg[g->start - 1])
g->start--; g->start--;
return 0; return 0;
} else { } else {
* Keep track of the last "end" index that causes this * Keep track of the last "end" index that causes this
* group to align with a group of changed lines in the * group to align with a group of changed lines in the
* other file. -1 indicates that we haven't found such * other file. -1 indicates that we haven't found such
* a match yet: * a match yet:
*/ */
end_matching_other = -1; end_matching_other = -1;
/* Shift the group backward as much as possible: */ /* Shift the group backward as much as possible: */
while (!group_slide_up(xdf, &g, flags)) while (!group_slide_up(xdf, &g))
if (group_previous(xdfo, &go)) if (group_previous(xdfo, &go))
xdl_bug("group sync broken sliding up"); xdl_bug("group sync broken sliding up");
/* /*
* This is this highest that this group can be shifted. * This is this highest that this group can be shifted.
* Record its end index: * Record its end index:
*/ */
earliest_end = g.end; earliest_end = g.end;
if (go.end > go.start) if (go.end > go.start)
end_matching_other = g.end; end_matching_other = g.end;
/* Now shift the group forward as far as possible: */ /* Now shift the group forward as far as possible: */
while (1) { while (1) {
if (group_slide_down(xdf, &g, flags)) if (group_slide_down(xdf, &g))
break; break;
if (group_next(xdfo, &go)) if (group_next(xdfo, &go))
xdl_bug("group sync broken sliding down"); xdl_bug("group sync broken sliding down");
if (go.end > go.start) if (go.end > go.start)
end_matching_other = g.end; end_matching_other = g.end;
} }
} while (groupsize != g.end - g.start); } while (groupsize != g.end - g.start);
/* no shifting was possible */ /* no shifting was possible */
} else if (end_matching_other != -1) { } else if (end_matching_other != -1) {
/* /*
* Move the possibly merged group of changes back to line * Move the possibly merged group of changes back to line
* up with the last group of changes from the other file * up with the last group of changes from the other file
* that it can align with. * that it can align with.
*/ */
while (go.end == go.start) { while (go.end == go.start) {
if (group_slide_up(xdf, &g, flags)) if (group_slide_up(xdf, &g))
xdl_bug("match disappeared"); xdl_bug("match disappeared");
if (group_previous(xdfo, &go)) if (group_previous(xdfo, &go))
xdl_bug("group sync broken sliding to match"); xdl_bug("group sync broken sliding to match");
} }
} else if (flags & XDF_INDENT_HEURISTIC) { } else if (flags & XDF_INDENT_HEURISTIC) {
/* /*
* Indent heuristic: a group of pure add/delete lines * Indent heuristic: a group of pure add/delete lines
* implies two splits, one between the end of the "before" * implies two splits, one between the end of the "before"
} else { } else {
boring += 1; boring += 1;
if (boring >= MAX_BORING) if (boring >= MAX_BORING)
break; break;
} }
} }
while (g.end > best_shift) { while (g.end > best_shift) {
if (group_slide_up(xdf, &g, flags)) if (group_slide_up(xdf, &g))
xdl_bug("best shift unreached"); xdl_bug("best shift unreached");
if (group_previous(xdfo, &go)) if (group_previous(xdfo, &go))
xdl_bug("group sync broken sliding to blank line"); xdl_bug("group sync broken sliding to blank line");
} }
} }
next: next:
/* Move past the just-processed group: */ /* Move past the just-processed group: */

mercurial/thirdparty/xdiff/xprepare.c

xdlclass_t *rcrec; xdlclass_t *rcrec;
xdlclass_t **rcrecs; xdlclass_t **rcrecs;
line = rec->ptr; line = rec->ptr;
hi = (long) XDL_HASHLONG(rec->ha, cf->hbits); hi = (long) XDL_HASHLONG(rec->ha, cf->hbits);
for (rcrec = cf->rchash[hi]; rcrec; rcrec = rcrec->next) for (rcrec = cf->rchash[hi]; rcrec; rcrec = rcrec->next)
if (rcrec->ha == rec->ha && if (rcrec->ha == rec->ha &&
xdl_recmatch(rcrec->line, rcrec->size, xdl_recmatch(rcrec->line, rcrec->size,
rec->ptr, rec->size, cf->flags)) rec->ptr, rec->size))
break; break;
if (!rcrec) { if (!rcrec) {
if (!(rcrec = xdl_cha_alloc(&cf->ncha))) { if (!(rcrec = xdl_cha_alloc(&cf->ncha))) {
return -1; return -1;
} }
rcrec->idx = cf->count++; rcrec->idx = cf->count++;
goto abort; goto abort;
memset(rhash, 0, hsize * sizeof(xrecord_t *)); memset(rhash, 0, hsize * sizeof(xrecord_t *));
} }
nrec = 0; nrec = 0;
if ((cur = blk = xdl_mmfile_first(mf, &bsize)) != NULL) { if ((cur = blk = xdl_mmfile_first(mf, &bsize)) != NULL) {
for (top = blk + bsize; cur < top; ) { for (top = blk + bsize; cur < top; ) {
prev = cur; prev = cur;
hav = xdl_hash_record(&cur, top, xpp->flags); hav = xdl_hash_record(&cur, top);
if (nrec >= narec) { if (nrec >= narec) {
narec *= 2; narec *= 2;
if (!(rrecs = (xrecord_t **) xdl_realloc(recs, narec * sizeof(xrecord_t *)))) if (!(rrecs = (xrecord_t **) xdl_realloc(recs, narec * sizeof(xrecord_t *))))
goto abort; goto abort;
recs = rrecs; recs = rrecs;
} }
if (!(crec = xdl_cha_alloc(&xdf->rcha))) if (!(crec = xdl_cha_alloc(&xdf->rcha)))
goto abort; goto abort;

mercurial/thirdparty/xdiff/xutils.h

int64_t xdl_bogosqrt(int64_t n); int64_t xdl_bogosqrt(int64_t n);
int xdl_cha_init(chastore_t *cha, int64_t isize, int64_t icount); int xdl_cha_init(chastore_t *cha, int64_t isize, int64_t 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);
int64_t xdl_guess_lines(mmfile_t *mf, int64_t sample); int64_t xdl_guess_lines(mmfile_t *mf, int64_t sample);
int xdl_recmatch(const char *l1, int64_t s1, const char *l2, int64_t s2, int64_t flags); int xdl_recmatch(const char *l1, int64_t s1, const char *l2, int64_t s2);
uint64_t xdl_hash_record(char const **data, char const *top, int64_t flags); uint64_t xdl_hash_record(char const **data, char const *top);
unsigned int xdl_hashbits(unsigned int size); unsigned int xdl_hashbits(unsigned int size);
#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_recmatch(const char *l1, int64_t s1, const char *l2, int64_t s2, int64_t flags) int xdl_recmatch(const char *l1, int64_t s1, const char *l2, int64_t s2)
{ {
if (s1 == s2 && !memcmp(l1, l2, s1)) if (s1 == s2 && !memcmp(l1, l2, s1))
return 1; return 1;
return 0; return 0;
} }
uint64_t xdl_hash_record(char const **data, char const *top, int64_t flags) { uint64_t xdl_hash_record(char const **data, char const *top) {
uint64_t ha = 5381; uint64_t ha = 5381;
char const *ptr = *data; char const *ptr = *data;
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;