This is an archive of the discontinued Mercurial Phabricator instance.

Differential D1007

bdiff: re-wrap lines per clang-format
ClosedPublic

Authored by durin42 on Oct 11 2017, 11:00 AM.

Details

Reviewers
pulkit
ryanmce
Group Reviewers
hg-reviewers
Commits
rHG38463bd96d21: bdiff: re-wrap lines per clang-format
Summary

A few too-wide lines corrected, and some places where clang-format
prefers to wrap after the binary operator instead of before. I don't
feel strongly, so I'm leaving the auto-format result as "after the
binary operator".

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

durin42 created this revision.Oct 11 2017, 11:00 AM
pulkit accepted this revision.Oct 11 2017, 2:25 PM
ryanmce accepted this revision.Oct 12 2017, 7:10 AM
This revision is now accepted and ready to land.Oct 12 2017, 7:10 AM
Closed by commit rHG38463bd96d21: bdiff: re-wrap lines per clang-format (authored by durin42). · Explain WhyOct 12 2017, 7:16 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/bdiff.c (19 lines)

Diff 2619

mercurial/bdiff.c

l->hash = 0; l->hash = 0;
l->len = 0; l->len = 0;
l->l = a + len; l->l = a + len;
return i - 1; return i - 1;
} }
static inline int cmp(struct bdiff_line *a, struct bdiff_line *b) static inline int cmp(struct bdiff_line *a, struct bdiff_line *b)
{ {
return a->hash != b->hash || a->len != b->len || memcmp(a->l, b->l, a->len); return a->hash != b->hash || a->len != b->len ||
memcmp(a->l, b->l, a->len);
} }
static int equatelines(struct bdiff_line *a, int an, struct bdiff_line *b, static int equatelines(struct bdiff_line *a, int an, struct bdiff_line *b,
int bn) int bn)
{ {
int i, j, buckets = 1, t, scale; int i, j, buckets = 1, t, scale;
struct pos *h = NULL; struct pos *h = NULL;
} }
if (mk) { if (mk) {
mi = mi - mk + 1; mi = mi - mk + 1;
mj = mj - mk + 1; mj = mj - mk + 1;
} }
/* expand match to include subsequent popular lines */ /* expand match to include subsequent popular lines */
while (mi + mk < a2 && mj + mk < b2 && while (mi + mk < a2 && mj + mk < b2 && a[mi + mk].e == b[mj + mk].e)
a[mi + mk].e == b[mj + mk].e)
mk++; mk++;
*omi = mi; *omi = mi;
*omj = mj; *omj = mj;
return mk; return mk;
} }
if (!k) if (!k)
return l; return l;
/* and recurse on the remaining chunks on either side */ /* and recurse on the remaining chunks on either side */
l = recurse(a, b, pos, a1, i, b1, j, l); l = recurse(a, b, pos, a1, i, b1, j, l);
if (!l) if (!l)
return NULL; return NULL;
l->next = (struct bdiff_hunk *)malloc(sizeof(struct bdiff_hunk)); l->next =
(struct bdiff_hunk *)malloc(sizeof(struct bdiff_hunk));
if (!l->next) if (!l->next)
return NULL; return NULL;
l = l->next; l = l->next;
l->a1 = i; l->a1 = i;
l->a2 = i + k; l->a2 = i + k;
l->b1 = j; l->b1 = j;
l->b2 = j + k; l->b2 = j + k;
if (pos && t) { if (pos && t) {
/* generate the matching block list */ /* generate the matching block list */
curr = recurse(a, b, pos, 0, an, 0, bn, base); curr = recurse(a, b, pos, 0, an, 0, bn, base);
if (!curr) if (!curr)
return -1; return -1;
/* sentinel end hunk */ /* sentinel end hunk */
curr->next = (struct bdiff_hunk *)malloc(sizeof(struct bdiff_hunk)); curr->next =
(struct bdiff_hunk *)malloc(sizeof(struct bdiff_hunk));
if (!curr->next) if (!curr->next)
return -1; return -1;
curr = curr->next; curr = curr->next;
curr->a1 = curr->a2 = an; curr->a1 = curr->a2 = an;
curr->b1 = curr->b2 = bn; curr->b1 = curr->b2 = bn;
curr->next = NULL; curr->next = NULL;
} }
free(pos); free(pos);
/* normalize the hunk list, try to push each hunk towards the end */ /* normalize the hunk list, try to push each hunk towards the end */
for (curr = base->next; curr; curr = curr->next) { for (curr = base->next; curr; curr = curr->next) {
struct bdiff_hunk *next = curr->next; struct bdiff_hunk *next = curr->next;
if (!next) if (!next)
break; break;
if (curr->a2 == next->a1 || curr->b2 == next->b1) if (curr->a2 == next->a1 || curr->b2 == next->b1)
while (curr->a2 < an && curr->b2 < bn while (curr->a2 < an && curr->b2 < bn &&
&& next->a1 < next->a2 next->a1 < next->a2 && next->b1 < next->b2 &&
&& next->b1 < next->b2 !cmp(a + curr->a2, b + curr->b2)) {
&& !cmp(a + curr->a2, b + curr->b2)) {
curr->a2++; curr->a2++;
next->a1++; next->a1++;
curr->b2++; curr->b2++;
next->b1++; next->b1++;
} }
} }
for (curr = base->next; curr; curr = curr->next) for (curr = base->next; curr; curr = curr->next)