( )⚙ D2764 xdiff: remove unused xpp and xecfg parameters

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D2764

xdiff: remove unused xpp and xecfg parameters
ClosedPublic

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

Details

Reviewers
indygreg
Group Reviewers
hg-reviewers
Commits
rHGf0d9811dda8e: xdiff: remove unused xpp and xecfg parameters
rHG2e2b48cca761: xdiff: remove unused xpp and xecfg parameters
Summary

They are unused. Thus removed.

Diff Detail

Repository
rHG Mercurial
Lint
Lint Skipped
Unit
Unit Tests Skipped

Event Timeline

quark created this revision.Mar 9 2018, 5:54 PM
indygreg accepted this revision.Mar 9 2018, 6:21 PM
This revision is now accepted and ready to land.Mar 9 2018, 6:21 PM
Closed by commit rHG2e2b48cca761: xdiff: remove unused xpp and xecfg parameters (authored by quark). · Explain WhyMar 9 2018, 6:24 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 6801

mercurial/thirdparty/xdiff/xdiffi.c

} }
/* /*
* Starting at the passed change atom, find the latest change atom to be included * Starting at the passed change atom, find the latest change atom to be included
* inside the differential hunk according to the specified configuration. * inside the differential hunk according to the specified configuration.
* Also advance xscr if the first changes must be discarded. * Also advance xscr if the first changes must be discarded.
*/ */
xdchange_t *xdl_get_hunk(xdchange_t **xscr, xdemitconf_t const *xecfg) xdchange_t *xdl_get_hunk(xdchange_t **xscr)
{ {
xdchange_t *xch, *xchp, *lxch; xdchange_t *xch, *xchp, *lxch;
int64_t max_common = 0; int64_t max_common = 0;
int64_t max_ignorable = 0; int64_t max_ignorable = 0;
uint64_t ignored = 0; /* number of ignored blank lines */ uint64_t ignored = 0; /* number of ignored blank lines */
/* remove ignorable changes that are too far before other changes */ /* remove ignorable changes that are too far before other changes */
for (xchp = *xscr; xchp && xchp->ignore; xchp = xchp->next) { for (xchp = *xscr; xchp && xchp->ignore; xchp = xchp->next) {
xdchange_t *xch, *xche; xdchange_t *xch, *xche;
if (!xecfg->hunk_func) if (!xecfg->hunk_func)
return -1; return -1;
if ((xecfg->flags & XDL_EMIT_BDIFFHUNK) != 0) { if ((xecfg->flags & XDL_EMIT_BDIFFHUNK) != 0) {
int64_t i1 = 0, i2 = 0, n1 = xe->xdf1.nrec, n2 = xe->xdf2.nrec; int64_t i1 = 0, i2 = 0, n1 = xe->xdf1.nrec, n2 = xe->xdf2.nrec;
for (xch = xscr; xch; xch = xche->next) { for (xch = xscr; xch; xch = xche->next) {
xche = xdl_get_hunk(&xch, xecfg); xche = xdl_get_hunk(&xch);
if (!xch) if (!xch)
break; break;
if (xch != xche) if (xch != xche)
xdl_bug("xch != xche"); xdl_bug("xch != xche");
xch->i1 += p; xch->i1 += p;
xch->i2 += p; xch->i2 += p;
if (xch->i1 > i1 || xch->i2 > i2) { if (xch->i1 > i1 || xch->i2 > i2) {
if (xecfg->hunk_func(i1, xch->i1, i2, xch->i2, ecb->priv) < 0) if (xecfg->hunk_func(i1, xch->i1, i2, xch->i2, ecb->priv) < 0)
return -1; return -1;
} }
i1 = xche->i1 + xche->chg1; i1 = xche->i1 + xche->chg1;
i2 = xche->i2 + xche->chg2; i2 = xche->i2 + xche->chg2;
} }
if (xecfg->hunk_func(i1, n1 + p + s, i2, n2 + p + s, if (xecfg->hunk_func(i1, n1 + p + s, i2, n2 + p + s,
ecb->priv) < 0) ecb->priv) < 0)
return -1; return -1;
} else { } else {
for (xch = xscr; xch; xch = xche->next) { for (xch = xscr; xch; xch = xche->next) {
xche = xdl_get_hunk(&xch, xecfg); xche = xdl_get_hunk(&xch);
if (!xch) if (!xch)
break; break;
if (xecfg->hunk_func(xch->i1 + p, if (xecfg->hunk_func(xch->i1 + p,
xche->i1 + xche->chg1 - xch->i1, xche->i1 + xche->chg1 - xch->i1,
xch->i2 + p, xch->i2 + p,
xche->i2 + xche->chg2 - xch->i2, xche->i2 + xche->chg2 - xch->i2,
ecb->priv) < 0) ecb->priv) < 0)
return -1; return -1;

mercurial/thirdparty/xdiff/xprepare.c

static int xdl_init_classifier(xdlclassifier_t *cf, int64_t size, int64_t flags); static int xdl_init_classifier(xdlclassifier_t *cf, int64_t size, int64_t flags);
static void xdl_free_classifier(xdlclassifier_t *cf); static void xdl_free_classifier(xdlclassifier_t *cf);
static int xdl_classify_record(unsigned int pass, xdlclassifier_t *cf, xrecord_t **rhash, static int xdl_classify_record(unsigned int pass, xdlclassifier_t *cf, xrecord_t **rhash,
unsigned int hbits, xrecord_t *rec); unsigned int hbits, xrecord_t *rec);
static int xdl_prepare_ctx(unsigned int pass, mmfile_t *mf, int64_t narec, xpparam_t const *xpp, static int xdl_prepare_ctx(unsigned int pass, mmfile_t *mf, int64_t narec,
xdlclassifier_t *cf, xdfile_t *xdf); xdlclassifier_t *cf, xdfile_t *xdf);
static void xdl_free_ctx(xdfile_t *xdf); static void xdl_free_ctx(xdfile_t *xdf);
static int xdl_clean_mmatch(char const *dis, int64_t i, int64_t s, int64_t e); static int xdl_clean_mmatch(char const *dis, int64_t i, int64_t s, int64_t e);
static int xdl_cleanup_records(xdlclassifier_t *cf, xdfile_t *xdf1, xdfile_t *xdf2); static int xdl_cleanup_records(xdlclassifier_t *cf, xdfile_t *xdf1, xdfile_t *xdf2);
static int xdl_trim_ends(xdfile_t *xdf1, xdfile_t *xdf2); static int xdl_trim_ends(xdfile_t *xdf1, xdfile_t *xdf2);
static int xdl_optimize_ctxs(xdlclassifier_t *cf, xdfile_t *xdf1, xdfile_t *xdf2); static int xdl_optimize_ctxs(xdlclassifier_t *cf, xdfile_t *xdf1, xdfile_t *xdf2);
xe->nsuffix = slines; xe->nsuffix = slines;
out_mf1->ptr = mf1->ptr + pbytes; out_mf1->ptr = mf1->ptr + pbytes;
out_mf1->size = mf1->size - pbytes - sbytes; out_mf1->size = mf1->size - pbytes - sbytes;
out_mf2->ptr = mf2->ptr + pbytes; out_mf2->ptr = mf2->ptr + pbytes;
out_mf2->size = mf2->size - pbytes - sbytes; out_mf2->size = mf2->size - pbytes - sbytes;
} }
static int xdl_prepare_ctx(unsigned int pass, mmfile_t *mf, int64_t narec, xpparam_t const *xpp, static int xdl_prepare_ctx(unsigned int pass, mmfile_t *mf, int64_t narec,
xdlclassifier_t *cf, xdfile_t *xdf) { xdlclassifier_t *cf, xdfile_t *xdf) {
unsigned int hbits; unsigned int hbits;
int64_t nrec, hsize, bsize; int64_t nrec, hsize, bsize;
uint64_t hav; uint64_t hav;
char const *blk, *cur, *top, *prev; char const *blk, *cur, *top, *prev;
xrecord_t *crec; xrecord_t *crec;
xrecord_t **recs, **rrecs; xrecord_t **recs, **rrecs;
xrecord_t **rhash; xrecord_t **rhash;
enl1 = xdl_guess_lines(mf1, sample) + 1; enl1 = xdl_guess_lines(mf1, sample) + 1;
enl2 = xdl_guess_lines(mf2, sample) + 1; enl2 = xdl_guess_lines(mf2, sample) + 1;
if (xdl_init_classifier(&cf, enl1 + enl2 + 1, xpp->flags) < 0) if (xdl_init_classifier(&cf, enl1 + enl2 + 1, xpp->flags) < 0)
return -1; return -1;
xdl_trim_files(mf1, mf2, TRIM_RESERVED_LINES, xe, &tmf1, &tmf2); xdl_trim_files(mf1, mf2, TRIM_RESERVED_LINES, xe, &tmf1, &tmf2);
if (xdl_prepare_ctx(1, &tmf1, enl1, xpp, &cf, &xe->xdf1) < 0) { if (xdl_prepare_ctx(1, &tmf1, enl1, &cf, &xe->xdf1) < 0) {
xdl_free_classifier(&cf); xdl_free_classifier(&cf);
return -1; return -1;
} }
if (xdl_prepare_ctx(2, &tmf2, enl2, xpp, &cf, &xe->xdf2) < 0) { if (xdl_prepare_ctx(2, &tmf2, enl2, &cf, &xe->xdf2) < 0) {
xdl_free_ctx(&xe->xdf1); xdl_free_ctx(&xe->xdf1);
xdl_free_classifier(&cf); xdl_free_classifier(&cf);
return -1; return -1;
} }
if (xdl_optimize_ctxs(&cf, &xe->xdf1, &xe->xdf2) < 0) { if (xdl_optimize_ctxs(&cf, &xe->xdf1, &xe->xdf2) < 0) {
xdl_free_ctx(&xe->xdf2); xdl_free_ctx(&xe->xdf2);