Document git-var -l listing also configuration variables

[git.git] / combine-diff.c

diff --git a/combine-diff.c b/combine-diff.c
index 672262a..9445e86 100644 (file)
--- a/combine-diff.c
+++ b/combine-diff.c
@@ -301,14 +301,14 @@ static unsigned long find_next(struct sline *sline,
         * lines that are not interesting to interesting() function
         * that are surrounded by interesting() ones.
         */
-       while (i < cnt)
+       while (i <= cnt)
                if (uninteresting
                    ? !(sline[i].flag & mark)
                    : (sline[i].flag & mark))
                        return i;
                else
                        i++;
-       return cnt;
+       return i;
 }
 
 static int give_context(struct sline *sline, unsigned long cnt, int num_parent)
@@ -327,10 +327,10 @@ static int give_context(struct sline *sline, unsigned long cnt, int num_parent)
         * lines but they are treated as "interesting" in the end.
         */
        i = find_next(sline, mark, 0, cnt, 0);
-       if (cnt <= i)
+       if (cnt < i)
                return 0;
 
-       while (i < cnt) {
+       while (i <= cnt) {
                unsigned long j = (context < i) ? (i - context) : 0;
                unsigned long k;
 
@@ -343,7 +343,7 @@ static int give_context(struct sline *sline, unsigned long cnt, int num_parent)
                 * next uninteresting one start?
                 */
                j = find_next(sline, mark, i, cnt, 1);
-               if (cnt <= j)
+               if (cnt < j)
                        break; /* the rest are all interesting */
 
                /* lookahead context lines */
@@ -365,7 +365,7 @@ static int give_context(struct sline *sline, unsigned long cnt, int num_parent)
                 * the trailing edge a bit.
                 */
                i = k;
-               k = (j + context < cnt) ? j + context : cnt;
+               k = (j + context < cnt+1) ? j + context : cnt+1;
                while (j < k)
                        sline[j++].flag |= mark;
        }
@@ -380,7 +380,7 @@ static int make_hunks(struct sline *sline, unsigned long cnt,
        unsigned long i;
        int has_interesting = 0;
 
-       for (i = 0; i < cnt; i++) {
+       for (i = 0; i <= cnt; i++) {
                if (interesting(&sline[i], all_mask))
                        sline[i].flag |= mark;
                else
@@ -394,15 +394,15 @@ static int make_hunks(struct sline *sline, unsigned long cnt,
         * parent, mark that uninteresting.
         */
        i = 0;
-       while (i < cnt) {
+       while (i <= cnt) {
                unsigned long j, hunk_begin, hunk_end;
                unsigned long same_diff;
-               while (i < cnt && !(sline[i].flag & mark))
+               while (i <= cnt && !(sline[i].flag & mark))
                        i++;
-               if (cnt <= i)
+               if (cnt < i)
                        break; /* No more interesting hunks */
                hunk_begin = i;
-               for (j = i + 1; j < cnt; j++) {
+               for (j = i + 1; j <= cnt; j++) {
                        if (!(sline[j].flag & mark)) {
                                /* Look beyond the end to see if there
                                 * is an interesting line after this
@@ -412,8 +412,8 @@ static int make_hunks(struct sline *sline, unsigned long cnt,
                                int contin = 0;
                                la = adjust_hunk_tail(sline, all_mask,
                                                     hunk_begin, j);
-                               la = (la + context < cnt) ?
-                                       (la + context) : cnt;
+                               la = (la + context < cnt + 1) ?
+                                       (la + context) : cnt + 1;
                                while (j <= --la) {
                                        if (sline[la].flag & mark) {
                                                contin = 1;
@@ -506,31 +506,24 @@ static void dump_sline(struct sline *sline, unsigned long cnt, int num_parent)
 
        while (1) {
                struct sline *sl = &sline[lno];
-               int hunk_end;
-               while (lno < cnt && !(sline[lno].flag & mark))
+               unsigned long hunk_end;
+               unsigned long rlines;
+               while (lno <= cnt && !(sline[lno].flag & mark))
                        lno++;
                if (cnt < lno)
                        break;
-               else if (cnt == lno) {
-                       /* See if there is anything interesting */
-                       struct lline *ll;
-                       for (ll = sline[lno].lost_head; ll; ll = ll->next)
-                               if (ll->parent_map)
-                                       break;
-                       if (!ll)
-                               break;
-                       hunk_end = cnt + 1;
-               }
                else {
-                       for (hunk_end = lno + 1; hunk_end < cnt; hunk_end++)
+                       for (hunk_end = lno + 1; hunk_end <= cnt; hunk_end++)
                                if (!(sline[hunk_end].flag & mark))
                                        break;
                }
+               rlines = hunk_end - lno;
+               if (cnt < hunk_end)
+                       rlines--; /* pointing at the last delete hunk */
                for (i = 0; i <= num_parent; i++) putchar(combine_marker);
                for (i = 0; i < num_parent; i++)
                        show_parent_lno(sline, lno, hunk_end, cnt, i);
-               printf(" +%lu,%lu ", lno+1,
-                      (cnt == lno) ? 0 : hunk_end - lno);
+               printf(" +%lu,%lu ", lno+1, rlines);
                for (i = 0; i <= num_parent; i++) putchar(combine_marker);
                putchar('\n');
                while (lno < hunk_end) {
@@ -549,7 +542,7 @@ static void dump_sline(struct sline *sline, unsigned long cnt, int num_parent)
                                puts(ll->line);
                                ll = ll->next;
                        }
-                       if (cnt <= lno)
+                       if (cnt < lno)
                                break;
                        p_mask = 1;
                        for (j = 0; j < num_parent; j++) {
@@ -596,7 +589,7 @@ static int show_patch_diff(struct combine_diff_path *elem, int num_parent,
                           struct diff_options *opt)
 {
        unsigned long result_size, cnt, lno;
-       char *result, *cp, *ep;
+       char *result, *cp;
        struct sline *sline; /* survived lines */
        int mode_differs = 0;
        int i, show_hunks, shown_header = 0;
@@ -648,7 +641,6 @@ static int show_patch_diff(struct combine_diff_path *elem, int num_parent,
                cnt++; /* incomplete line */
 
        sline = xcalloc(cnt+2, sizeof(*sline));
-       ep = result;
        sline[0].bol = result;
        for (lno = 0; lno <= cnt + 1; lno++) {
                sline[lno].lost_tail = &sline[lno].lost_head;
@@ -759,7 +751,7 @@ static int show_patch_diff(struct combine_diff_path *elem, int num_parent,
 
 static void show_raw_diff(struct combine_diff_path *p, int num_parent, const char *header, struct diff_options *opt)
 {
-       int i, offset, mod_type = 'A';
+       int i, offset;
        const char *prefix;
        int line_termination, inter_name_termination;
 
@@ -771,13 +763,6 @@ static void show_raw_diff(struct combine_diff_path *p, int num_parent, const cha
        if (header)
                printf("%s%c", header, line_termination);
 
-       for (i = 0; i < num_parent; i++) {
-               if (p->parent[i].mode)
-                       mod_type = 'M';
-       }
-       if (!p->mode)
-               mod_type = 'D';
-
        if (opt->output_format == DIFF_FORMAT_RAW) {
                offset = strlen(COLONS) - num_parent;
                if (offset < 0)
@@ -850,6 +835,7 @@ const char *diff_tree_combined_merge(const unsigned char *sha1,
 
        diffopts = *opt;
        diffopts.output_format = DIFF_FORMAT_NO_OUTPUT;
+       diffopts.with_raw = 0;
        diffopts.recursive = 1;
 
        /* count parents */
@@ -876,6 +862,17 @@ const char *diff_tree_combined_merge(const unsigned char *sha1,
                        num_paths++;
        }
        if (num_paths) {
+               if (opt->with_raw) {
+                       int saved_format = opt->output_format;
+                       opt->output_format = DIFF_FORMAT_RAW;
+                       for (p = paths; p; p = p->next) {
+                               if (show_combined_diff(p, num_parent, dense,
+                                                      header, opt))
+                                       header = NULL;
+                       }
+                       opt->output_format = saved_format;
+                       putchar(opt->line_termination);
+               }
                for (p = paths; p; p = p->next) {
                        if (show_combined_diff(p, num_parent, dense,
                                               header, opt))