struct lline *lost_head, **lost_tail;
char *bol;
int len;
- /* bit 0 up to (N-1) are on if the parent does _not_
- * have this line (i.e. we changed it).
+ /* bit 0 up to (N-1) are on if the parent has this line (i.e.
+ * we did not change it).
* bit N is used for "interesting" lines, including context.
*/
unsigned long flag;
+ unsigned long *p_lno;
};
static char *grab_blob(const unsigned char *sha1, unsigned long *size)
}
static void combine_diff(const unsigned char *parent, const char *ourtmp,
- struct sline *sline, int cnt, int n)
+ struct sline *sline, int cnt, int n, int num_parent)
{
FILE *in;
char parent_tmp[TMPPATHLEN];
char cmd[TMPPATHLEN * 2 + 1024];
char line[MAXLINELEN];
- unsigned int lno, ob, on, nb, nn;
- unsigned long pmask = ~(1UL << n);
+ unsigned int lno, ob, on, nb, nn, p_lno;
+ unsigned long nmask = (1UL << n);
struct sline *lost_bucket = NULL;
write_temp_blob(parent_tmp, parent);
parent_tmp, ourtmp);
in = popen(cmd, "r");
if (!in)
- return;
+ die("cannot spawn %s", cmd);
lno = 1;
while (fgets(line, sizeof(line), in) != NULL) {
&ob, &on, &nb, &nn))
break;
lno = nb;
- if (!nb) {
+ if (!nb)
/* @@ -1,2 +0,0 @@ to remove the
* first two lines...
*/
nb = 1;
- }
if (nn == 0)
+ /* @@ -X,Y +N,0 @@ removed Y lines
+ * that would have come *after* line N
+ * in the result. Our lost buckets hang
+ * to the line after the removed lines,
+ */
lost_bucket = &sline[nb];
else
lost_bucket = &sline[nb-1];
+ if (!sline[nb-1].p_lno)
+ sline[nb-1].p_lno =
+ xcalloc(num_parent,
+ sizeof(unsigned long));
+ sline[nb-1].p_lno[n] = ob;
continue;
}
if (!lost_bucket)
append_lost(lost_bucket, n, line+1);
break;
case '+':
- sline[lno-1].flag &= pmask;
+ sline[lno-1].flag |= nmask;
lno++;
break;
}
}
fclose(in);
unlink(parent_tmp);
+
+ /* Assign line numbers for this parent.
+ *
+ * sline[lno].p_lno[n] records the first line number
+ * (counting from 1) for parent N if the final hunk display
+ * started by showing sline[lno] (possibly showing the lost
+ * lines attached to it first).
+ */
+ for (lno = 0, p_lno = 1; lno < cnt; lno++) {
+ struct lline *ll;
+ sline[lno].p_lno[n] = p_lno;
+
+ /* How many lines would this sline advance the p_lno? */
+ ll = sline[lno].lost_head;
+ while (ll) {
+ if (ll->parent_map & nmask)
+ p_lno++; /* '-' means parent had it */
+ ll = ll->next;
+ }
+ if (!(sline[lno].flag & nmask))
+ p_lno++; /* no '+' means parent had it */
+ }
+ sline[lno].p_lno[n] = p_lno; /* trailer */
}
static unsigned long context = 3;
static int interesting(struct sline *sline, unsigned long all_mask)
{
- return ((sline->flag & all_mask) != all_mask || sline->lost_head);
+ /* If some parents lost lines here, or if we have added to
+ * some parent, it is interesting.
+ */
+ return ((sline->flag & all_mask) || sline->lost_head);
}
static unsigned long adjust_hunk_tail(struct sline *sline,
unsigned long hunk_begin,
unsigned long i)
{
- /* i points at the first uninteresting line.
- * If the last line of the hunk was interesting
- * only because it has some deletion, then
- * it is not all that interesting for the
- * purpose of giving trailing context lines.
+ /* i points at the first uninteresting line. If the last line
+ * of the hunk was interesting only because it has some
+ * deletion, then it is not all that interesting for the
+ * purpose of giving trailing context lines. This is because
+ * we output '-' line and then unmodified sline[i-1] itself in
+ * that case which gives us one extra context line.
*/
- if ((hunk_begin + 1 <= i) &&
- ((sline[i-1].flag & all_mask) == all_mask))
+ if ((hunk_begin + 1 <= i) && !(sline[i-1].flag & all_mask))
i--;
return i;
}
-static unsigned long next_interesting(struct sline *sline,
- unsigned long mark,
- unsigned long i,
- unsigned long cnt,
- int uninteresting)
+static unsigned long find_next(struct sline *sline,
+ unsigned long mark,
+ unsigned long i,
+ unsigned long cnt,
+ int uninteresting)
{
+ /* We have examined up to i-1 and are about to look at i.
+ * Find next interesting or uninteresting line. Here,
+ * "interesting" does not mean interesting(), but marked by
+ * the give_context() function below (i.e. it includes context
+ * lines that are not interesting to interesting() function
+ * that are surrounded by interesting() ones.
+ */
while (i < cnt)
- if (uninteresting ?
- !(sline[i].flag & mark) :
- (sline[i].flag & mark))
+ if (uninteresting
+ ? !(sline[i].flag & mark)
+ : (sline[i].flag & mark))
return i;
else
i++;
unsigned long mark = (1UL<<num_parent);
unsigned long i;
- i = next_interesting(sline, mark, 0, cnt, 0);
+ /* Two groups of interesting lines may have a short gap of
+ * unintersting lines. Connect such groups to give them a
+ * bit of context.
+ *
+ * We first start from what the interesting() function says,
+ * and mark them with "mark", and paint context lines with the
+ * mark. So interesting() would still say false for such context
+ * lines but they are treated as "interesting" in the end.
+ */
+ i = find_next(sline, mark, 0, cnt, 0);
if (cnt <= i)
return 0;
while (i < cnt) {
unsigned long j = (context < i) ? (i - context) : 0;
unsigned long k;
+
+ /* Paint a few lines before the first interesting line. */
while (j < i)
sline[j++].flag |= mark;
again:
- j = next_interesting(sline, mark, i, cnt, 1);
+ /* we know up to i is to be included. where does the
+ * next uninteresting one start?
+ */
+ j = find_next(sline, mark, i, cnt, 1);
if (cnt <= j)
break; /* the rest are all interesting */
/* lookahead context lines */
- k = next_interesting(sline, mark, j, cnt, 0);
+ k = find_next(sline, mark, j, cnt, 0);
j = adjust_hunk_tail(sline, all_mask, i, j);
if (k < j + context) {
}
/* j is the first uninteresting line and there is
- * no overlap beyond it within context lines.
+ * no overlap beyond it within context lines. Paint
+ * the trailing edge a bit.
*/
i = k;
k = (j + context < cnt) ? j + context : cnt;
same_diff = 0;
has_interesting = 0;
for (j = i; j < hunk_end && !has_interesting; j++) {
- unsigned long this_diff = ~sline[j].flag & all_mask;
+ unsigned long this_diff = sline[j].flag & all_mask;
struct lline *ll = sline[j].lost_head;
if (this_diff) {
/* This has some changes. Is it the
return has_interesting;
}
-static void dump_sline(struct sline *sline, int cnt, int num_parent)
+static void show_parent_lno(struct sline *sline, unsigned long l0, unsigned long l1, unsigned long cnt, int n)
+{
+ l0 = sline[l0].p_lno[n];
+ l1 = sline[l1].p_lno[n];
+ printf(" -%lu,%lu", l0, l1-l0);
+}
+
+static void dump_sline(struct sline *sline, unsigned long cnt, int num_parent)
{
unsigned long mark = (1UL<<num_parent);
int i;
- int lno = 0;
+ unsigned long lno = 0;
while (1) {
struct sline *sl = &sline[lno];
if (!(sline[hunk_end].flag & mark))
break;
for (i = 0; i <= num_parent; i++) putchar(combine_marker);
- printf(" +%d,%d ", lno+1, hunk_end-lno);
+ for (i = 0; i < num_parent; i++)
+ show_parent_lno(sline, lno, hunk_end, cnt, i);
+ printf(" +%lu,%lu ", lno+1, hunk_end-lno);
for (i = 0; i <= num_parent; i++) putchar(combine_marker);
putchar('\n');
while (lno < hunk_end) {
struct lline *ll;
int j;
+ unsigned long p_mask;
sl = &sline[lno++];
ll = sl->lost_head;
while (ll) {
puts(ll->line);
ll = ll->next;
}
+ p_mask = 1;
for (j = 0; j < num_parent; j++) {
- if ((1UL<<j) & sl->flag)
- putchar(' ');
- else
+ if (p_mask & sl->flag)
putchar('+');
+ else
+ putchar(' ');
+ p_mask <<= 1;
}
printf("%.*s\n", sl->len, sl->bol);
}
for (lno = 0; lno < cnt; lno++) {
struct lline *ll = sline->lost_head;
+ sline->p_lno[i] = sline->p_lno[j];
while (ll) {
if (ll->parent_map & jmask)
ll->parent_map |= imask;
ll = ll->next;
}
- if (!(sline->flag & jmask))
- sline->flag &= ~imask;
+ if (sline->flag & jmask)
+ sline->flag |= imask;
sline++;
}
}
if (result[size-1] != '\n')
cnt++; /* incomplete line */
- sline = xcalloc(cnt, sizeof(*sline));
+ sline = xcalloc(cnt+1, sizeof(*sline));
ep = result;
sline[0].bol = result;
for (lno = 0, cp = result; cp - result < size; cp++) {
if (*cp == '\n') {
sline[lno].lost_tail = &sline[lno].lost_head;
sline[lno].len = cp - sline[lno].bol;
- sline[lno].flag = (1UL<<num_parent) - 1;
+ sline[lno].flag = 0;
lno++;
if (lno < cnt)
sline[lno].bol = cp + 1;
if (result[size-1] != '\n') {
sline[cnt-1].lost_tail = &sline[cnt-1].lost_head;
sline[cnt-1].len = size - (sline[cnt-1].bol - result);
- sline[cnt-1].flag = (1UL<<num_parent) - 1;
+ sline[cnt-1].flag = 0;
}
+ sline[0].p_lno = xcalloc((cnt+1) * num_parent, sizeof(unsigned long));
+ for (lno = 0; lno < cnt; lno++)
+ sline[lno+1].p_lno = sline[lno].p_lno + num_parent;
+
for (i = 0; i < num_parent; i++) {
int j;
for (j = 0; j < i; j++) {
}
if (i <= j)
combine_diff(elem->parent_sha1[i], ourtmp, sline,
- cnt, i);
+ cnt, i, num_parent);
}
show_hunks = make_hunks(sline, cnt, num_parent, dense);
- if (header && (show_hunks || show_empty)) {
- shown_header++;
- puts(header);
- }
if (show_hunks) {
+ if (header) {
+ shown_header++;
+ puts(header);
+ }
printf("diff --%s ", dense ? "cc" : "combined");
if (quote_c_style(elem->path, NULL, NULL, 0))
quote_c_style(elem->path, NULL, stdout, 0);
printf("index ");
for (i = 0; i < num_parent; i++) {
printf("%s%s",
- i ? ".." : "",
+ i ? "," : "",
find_unique_abbrev(elem->parent_sha1[i],
DEFAULT_ABBREV));
}
- printf("->%s\n",
+ printf("..%s\n",
find_unique_abbrev(elem->sha1, DEFAULT_ABBREV));
dump_sline(sline, cnt, num_parent);
}
}
}
}
+ free(sline[0].p_lno);
free(sline);
return shown_header;
}
projects / git.git / blobdiff