Merge with_raw, with_stat and summary variables to output_format

DIFF_FORMAT_* are now bit-flags instead of enumerated values.

Signed-off-by: Timo Hirvonen <tihirvon@gmail.com>
Signed-off-by: Junio C Hamano <junkio@cox.net>

diff --git a/builtin-diff.c b/builtin-diff.c
index 99a2f766055d6c8c3231e38bd369169d3c742782..3b44296ff403d6b8928e147e781948645068fb02 100644 (file)
--- a/builtin-diff.c
+++ b/builtin-diff.c
@@ -56,7 +56,7 @@ static int builtin_diff_files(struct rev_info *revs,
            3 < revs->max_count)
                usage(builtin_diff_usage);
        if (revs->max_count < 0 &&
-           (revs->diffopt.output_format == DIFF_FORMAT_PATCH))
+           (revs->diffopt.output_format & DIFF_FORMAT_PATCH))
                revs->combine_merges = revs->dense_combined_merges = 1;
        /*
         * Backward compatibility wart - "diff-files -s" used to

diff --git a/builtin-log.c b/builtin-log.c
index 44d2d136f585a74e462556a4f756c7a297cadd51..e321959c56155289dcdb574aa11279e6f9335122 100644 (file)
--- a/builtin-log.c
+++ b/builtin-log.c
@@ -176,11 +176,9 @@ int cmd_format_patch(int argc, const char **argv, char **envp)
        rev.commit_format = CMIT_FMT_EMAIL;
        rev.verbose_header = 1;
        rev.diff = 1;
-       rev.diffopt.with_raw = 0;
-       rev.diffopt.with_stat = 1;
        rev.combine_merges = 0;
        rev.ignore_merges = 1;
-       rev.diffopt.output_format = DIFF_FORMAT_PATCH;
+       rev.diffopt.output_format = DIFF_FORMAT_DIFFSTAT | DIFF_FORMAT_PATCH;
 
        git_config(git_format_config);
        rev.extra_headers = extra_headers;

diff --git a/combine-diff.c b/combine-diff.c
index 64b20cce2427fcf0cd9565f5e24efce78abb0088..3daa8cb13eaebf0c7eb66bbc80a63436a00bb342 100644 (file)
--- a/combine-diff.c
+++ b/combine-diff.c
@@ -771,7 +771,7 @@ static void show_raw_diff(struct combine_diff_path *p, int num_parent, struct re
        if (rev->loginfo)
                show_log(rev, rev->loginfo, "\n");
 
-       if (opt->output_format == DIFF_FORMAT_RAW) {
+       if (opt->output_format & DIFF_FORMAT_RAW) {
                offset = strlen(COLONS) - num_parent;
                if (offset < 0)
                        offset = 0;
@@ -791,8 +791,7 @@ static void show_raw_diff(struct combine_diff_path *p, int num_parent, struct re
                printf(" %s ", diff_unique_abbrev(p->sha1, opt->abbrev));
        }
 
-       if (opt->output_format == DIFF_FORMAT_RAW ||
-           opt->output_format == DIFF_FORMAT_NAME_STATUS) {
+       if (opt->output_format & (DIFF_FORMAT_RAW | DIFF_FORMAT_NAME_STATUS)) {
                for (i = 0; i < num_parent; i++)
                        putchar(p->parent[i].status);
                putchar(inter_name_termination);
@@ -818,17 +817,12 @@ void show_combined_diff(struct combine_diff_path *p,
        struct diff_options *opt = &rev->diffopt;
        if (!p->len)
                return;
-       switch (opt->output_format) {
-       case DIFF_FORMAT_RAW:
-       case DIFF_FORMAT_NAME_STATUS:
-       case DIFF_FORMAT_NAME:
+       if (opt->output_format & (DIFF_FORMAT_RAW |
+                                 DIFF_FORMAT_NAME |
+                                 DIFF_FORMAT_NAME_STATUS)) {
                show_raw_diff(p, num_parent, rev);
-               return;
-       case DIFF_FORMAT_PATCH:
+       } else if (opt->output_format & DIFF_FORMAT_PATCH) {
                show_patch_diff(p, num_parent, dense, rev);
-               return;
-       default:
-               return;
        }
 }
 
@@ -842,13 +836,9 @@ void diff_tree_combined(const unsigned char *sha1,
        struct diff_options diffopts;
        struct combine_diff_path *p, *paths = NULL;
        int i, num_paths;
-       int do_diffstat;
 
-       do_diffstat = (opt->output_format == DIFF_FORMAT_DIFFSTAT ||
-                      opt->with_stat);
        diffopts = *opt;
-       diffopts.with_raw = 0;
-       diffopts.with_stat = 0;
+       diffopts.output_format &= ~(DIFF_FORMAT_RAW | DIFF_FORMAT_DIFFSTAT);
        diffopts.recursive = 1;
 
        /* find set of paths that everybody touches */
@@ -856,19 +846,18 @@ void diff_tree_combined(const unsigned char *sha1,
                /* show stat against the first parent even
                 * when doing combined diff.
                 */
-               if (i == 0 && do_diffstat)
-                       diffopts.output_format = DIFF_FORMAT_DIFFSTAT;
+               if (i == 0 && opt->output_format & DIFF_FORMAT_DIFFSTAT)
+                       diffopts.output_format |= DIFF_FORMAT_DIFFSTAT;
                else
-                       diffopts.output_format = DIFF_FORMAT_NO_OUTPUT;
+                       diffopts.output_format |= DIFF_FORMAT_NO_OUTPUT;
                diff_tree_sha1(parent[i], sha1, "", &diffopts);
                diffcore_std(&diffopts);
                paths = intersect_paths(paths, i, num_parent);
 
-               if (do_diffstat && rev->loginfo)
-                       show_log(rev, rev->loginfo,
-                                opt->with_stat ? "---\n" : "\n");
+               if (opt->output_format & DIFF_FORMAT_DIFFSTAT && rev->loginfo)
+                       show_log(rev, rev->loginfo, "---\n");
                diff_flush(&diffopts);
-               if (opt->with_stat)
+               if (opt->output_format & DIFF_FORMAT_DIFFSTAT)
                        putchar('\n');
        }
 
@@ -878,17 +867,21 @@ void diff_tree_combined(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;
+               if (opt->output_format & (DIFF_FORMAT_RAW |
+                                         DIFF_FORMAT_NAME |
+                                         DIFF_FORMAT_NAME_STATUS)) {
                        for (p = paths; p; p = p->next) {
-                               show_combined_diff(p, num_parent, dense, rev);
+                               if (p->len)
+                                       show_raw_diff(p, num_parent, rev);
                        }
-                       opt->output_format = saved_format;
                        putchar(opt->line_termination);
                }
-               for (p = paths; p; p = p->next) {
-                       show_combined_diff(p, num_parent, dense, rev);
+               if (opt->output_format & DIFF_FORMAT_PATCH) {
+                       for (p = paths; p; p = p->next) {
+                               if (p->len)
+                                       show_patch_diff(p, num_parent, dense,
+                                                       rev);
+                       }
                }
        }
 

diff --git a/diff.c b/diff.c
index fbb6c26cd9266e0ae453bb6c321f52d4996446a6..49b2eeb7419a910650ba38e054a99a615398eadb 100644 (file)
--- a/diff.c
+++ b/diff.c
@@ -1438,23 +1438,27 @@ int diff_setup_done(struct diff_options *options)
            (0 <= options->rename_limit && !options->detect_rename))
                return -1;
 
+       if (options->output_format & DIFF_FORMAT_NO_OUTPUT)
+               options->output_format = 0;
+
+       if (options->output_format & (DIFF_FORMAT_NAME |
+                                     DIFF_FORMAT_NAME_STATUS |
+                                     DIFF_FORMAT_CHECKDIFF |
+                                     DIFF_FORMAT_NO_OUTPUT))
+               options->output_format &= ~(DIFF_FORMAT_RAW |
+                                           DIFF_FORMAT_DIFFSTAT |
+                                           DIFF_FORMAT_SUMMARY |
+                                           DIFF_FORMAT_PATCH);
+
        /*
         * These cases always need recursive; we do not drop caller-supplied
         * recursive bits for other formats here.
         */
-       if ((options->output_format == DIFF_FORMAT_PATCH) ||
-           (options->output_format == DIFF_FORMAT_DIFFSTAT) ||
-           (options->output_format == DIFF_FORMAT_CHECKDIFF))
+       if (options->output_format & (DIFF_FORMAT_PATCH |
+                                     DIFF_FORMAT_DIFFSTAT |
+                                     DIFF_FORMAT_CHECKDIFF))
                options->recursive = 1;
 
-       /*
-        * These combinations do not make sense.
-        */
-       if (options->output_format == DIFF_FORMAT_RAW)
-               options->with_raw = 0;
-       if (options->output_format == DIFF_FORMAT_DIFFSTAT)
-               options->with_stat  = 0;
-
        if (options->detect_rename && options->rename_limit < 0)
                options->rename_limit = diff_rename_limit_default;
        if (options->setup & DIFF_SETUP_USE_CACHE) {
@@ -1526,22 +1530,20 @@ int diff_opt_parse(struct diff_options *options, const char **av, int ac)
 {
        const char *arg = av[0];
        if (!strcmp(arg, "-p") || !strcmp(arg, "-u"))
-               options->output_format = DIFF_FORMAT_PATCH;
+               options->output_format |= DIFF_FORMAT_PATCH;
        else if (opt_arg(arg, 'U', "unified", &options->context))
-               options->output_format = DIFF_FORMAT_PATCH;
+               options->output_format |= DIFF_FORMAT_PATCH;
        else if (!strcmp(arg, "--patch-with-raw")) {
-               options->output_format = DIFF_FORMAT_PATCH;
-               options->with_raw = 1;
+               options->output_format |= DIFF_FORMAT_PATCH | DIFF_FORMAT_RAW;
        }
        else if (!strcmp(arg, "--stat"))
-               options->output_format = DIFF_FORMAT_DIFFSTAT;
+               options->output_format |= DIFF_FORMAT_DIFFSTAT;
        else if (!strcmp(arg, "--check"))
-               options->output_format = DIFF_FORMAT_CHECKDIFF;
+               options->output_format |= DIFF_FORMAT_CHECKDIFF;
        else if (!strcmp(arg, "--summary"))
-               options->summary = 1;
+               options->output_format |= DIFF_FORMAT_SUMMARY;
        else if (!strcmp(arg, "--patch-with-stat")) {
-               options->output_format = DIFF_FORMAT_PATCH;
-               options->with_stat = 1;
+               options->output_format |= DIFF_FORMAT_PATCH | DIFF_FORMAT_DIFFSTAT;
        }
        else if (!strcmp(arg, "-z"))
                options->line_termination = 0;
@@ -1550,19 +1552,20 @@ int diff_opt_parse(struct diff_options *options, const char **av, int ac)
        else if (!strcmp(arg, "--full-index"))
                options->full_index = 1;
        else if (!strcmp(arg, "--binary")) {
-               options->output_format = DIFF_FORMAT_PATCH;
+               options->output_format |= DIFF_FORMAT_PATCH;
                options->full_index = options->binary = 1;
        }
        else if (!strcmp(arg, "--name-only"))
-               options->output_format = DIFF_FORMAT_NAME;
+               options->output_format |= DIFF_FORMAT_NAME;
        else if (!strcmp(arg, "--name-status"))
-               options->output_format = DIFF_FORMAT_NAME_STATUS;
+               options->output_format |= DIFF_FORMAT_NAME_STATUS;
        else if (!strcmp(arg, "-R"))
                options->reverse_diff = 1;
        else if (!strncmp(arg, "-S", 2))
                options->pickaxe = arg + 2;
-       else if (!strcmp(arg, "-s"))
-               options->output_format = DIFF_FORMAT_NO_OUTPUT;
+       else if (!strcmp(arg, "-s")) {
+               options->output_format |= DIFF_FORMAT_NO_OUTPUT;
+       }
        else if (!strncmp(arg, "-O", 2))
                options->orderfile = arg + 2;
        else if (!strncmp(arg, "--diff-filter=", 14))
@@ -1737,15 +1740,17 @@ const char *diff_unique_abbrev(const unsigned char *sha1, int len)
 }
 
 static void diff_flush_raw(struct diff_filepair *p,
-                          int line_termination,
-                          int inter_name_termination,
-                          struct diff_options *options,
-                          int output_format)
+                          struct diff_options *options)
 {
        int two_paths;
        char status[10];
        int abbrev = options->abbrev;
        const char *path_one, *path_two;
+       int inter_name_termination = '\t';
+       int line_termination = options->line_termination;
+
+       if (!line_termination)
+               inter_name_termination = 0;
 
        path_one = p->one->path;
        path_two = p->two->path;
@@ -1774,7 +1779,7 @@ static void diff_flush_raw(struct diff_filepair *p,
                two_paths = 0;
                break;
        }
-       if (output_format != DIFF_FORMAT_NAME_STATUS) {
+       if (!(options->output_format & DIFF_FORMAT_NAME_STATUS)) {
                printf(":%06o %06o %s ",
                       p->one->mode, p->two->mode,
                       diff_unique_abbrev(p->one->sha1, abbrev));
@@ -1983,48 +1988,30 @@ static void diff_resolve_rename_copy(void)
        diff_debug_queue("resolve-rename-copy done", q);
 }
 
-static void flush_one_pair(struct diff_filepair *p,
-                          int diff_output_format,
-                          struct diff_options *options,
-                          struct diffstat_t *diffstat)
+static int check_pair_status(struct diff_filepair *p)
 {
-       int inter_name_termination = '\t';
-       int line_termination = options->line_termination;
-       if (!line_termination)
-               inter_name_termination = 0;
-
        switch (p->status) {
        case DIFF_STATUS_UNKNOWN:
-               break;
+               return 0;
        case 0:
                die("internal error in diff-resolve-rename-copy");
-               break;
        default:
-               switch (diff_output_format) {
-               case DIFF_FORMAT_DIFFSTAT:
-                       diff_flush_stat(p, options, diffstat);
-                       break;
-               case DIFF_FORMAT_CHECKDIFF:
-                       diff_flush_checkdiff(p, options);
-                       break;
-               case DIFF_FORMAT_PATCH:
-                       diff_flush_patch(p, options);
-                       break;
-               case DIFF_FORMAT_RAW:
-               case DIFF_FORMAT_NAME_STATUS:
-                       diff_flush_raw(p, line_termination,
-                                      inter_name_termination,
-                                      options, diff_output_format);
-                       break;
-               case DIFF_FORMAT_NAME:
-                       diff_flush_name(p, line_termination);
-                       break;
-               case DIFF_FORMAT_NO_OUTPUT:
-                       break;
-               }
+               return 1;
        }
 }
 
+static void flush_one_pair(struct diff_filepair *p, struct diff_options *opt)
+{
+       int fmt = opt->output_format;
+
+       if (fmt & DIFF_FORMAT_CHECKDIFF)
+               diff_flush_checkdiff(p, opt);
+       else if (fmt & (DIFF_FORMAT_RAW | DIFF_FORMAT_NAME_STATUS))
+               diff_flush_raw(p, opt);
+       else if (fmt & DIFF_FORMAT_NAME)
+               diff_flush_name(p, opt->line_termination);
+}
+
 static void show_file_mode_name(const char *newdelete, struct diff_filespec *fs)
 {
        if (fs->mode)
@@ -2107,55 +2094,61 @@ static void diff_summary(struct diff_filepair *p)
 void diff_flush(struct diff_options *options)
 {
        struct diff_queue_struct *q = &diff_queued_diff;
-       int i;
-       int diff_output_format = options->output_format;
-       struct diffstat_t *diffstat = NULL;
+       int i, output_format = options->output_format;
 
-       if (diff_output_format == DIFF_FORMAT_DIFFSTAT || options->with_stat) {
-               diffstat = xcalloc(sizeof (struct diffstat_t), 1);
-               diffstat->xm.consume = diffstat_consume;
-       }
+       /*
+        * Order: raw, stat, summary, patch
+        * or:    name/name-status/checkdiff (other bits clear)
+        */
 
-       if (options->with_raw) {
+       if (output_format & (DIFF_FORMAT_RAW |
+                            DIFF_FORMAT_NAME |
+                            DIFF_FORMAT_NAME_STATUS |
+                            DIFF_FORMAT_CHECKDIFF)) {
                for (i = 0; i < q->nr; i++) {
                        struct diff_filepair *p = q->queue[i];
-                       flush_one_pair(p, DIFF_FORMAT_RAW, options, NULL);
+                       if (check_pair_status(p))
+                               flush_one_pair(p, options);
                }
-               putchar(options->line_termination);
        }
-       if (options->with_stat) {
+
+       if (output_format & DIFF_FORMAT_DIFFSTAT) {
+               struct diffstat_t *diffstat;
+
+               diffstat = xcalloc(sizeof (struct diffstat_t), 1);
+               diffstat->xm.consume = diffstat_consume;
                for (i = 0; i < q->nr; i++) {
                        struct diff_filepair *p = q->queue[i];
-                       flush_one_pair(p, DIFF_FORMAT_DIFFSTAT, options,
-                                      diffstat);
+                       if (check_pair_status(p))
+                               diff_flush_stat(p, options, diffstat);
                }
                show_stats(diffstat);
                free(diffstat);
-               diffstat = NULL;
-               if (options->summary)
-                       for (i = 0; i < q->nr; i++)
-                               diff_summary(q->queue[i]);
-               if (options->stat_sep)
-                       fputs(options->stat_sep, stdout);
-               else
-                       putchar(options->line_termination);
-       }
-       for (i = 0; i < q->nr; i++) {
-               struct diff_filepair *p = q->queue[i];
-               flush_one_pair(p, diff_output_format, options, diffstat);
        }
 
-       if (diffstat) {
-               show_stats(diffstat);
-               free(diffstat);
+       if (output_format & DIFF_FORMAT_SUMMARY) {
+               for (i = 0; i < q->nr; i++)
+                       diff_summary(q->queue[i]);
        }
 
-       for (i = 0; i < q->nr; i++) {
-               if (diffstat && options->summary)
-                       diff_summary(q->queue[i]);
-               diff_free_filepair(q->queue[i]);
+       if (output_format & DIFF_FORMAT_PATCH) {
+               if (output_format & (DIFF_FORMAT_DIFFSTAT |
+                                    DIFF_FORMAT_SUMMARY)) {
+                       if (options->stat_sep)
+                               fputs(options->stat_sep, stdout);
+                       else
+                               putchar(options->line_termination);
+               }
+
+               for (i = 0; i < q->nr; i++) {
+                       struct diff_filepair *p = q->queue[i];
+                       if (check_pair_status(p))
+                               diff_flush_patch(p, options);
+               }
        }
 
+       for (i = 0; i < q->nr; i++)
+               diff_free_filepair(q->queue[i]);
        free(q->queue);
        q->queue = NULL;
        q->nr = q->alloc = 0;

diff --git a/diff.h b/diff.h
index b61fdc8f1e4f34b608ed69cbbac6f74b81d47b53..2b6dc0cbe4d59614d5a8b44deb4052eb4a2991c1 100644 (file)
--- a/diff.h
+++ b/diff.h
@@ -20,19 +20,31 @@ typedef void (*add_remove_fn_t)(struct diff_options *options,
                    const unsigned char *sha1,
                    const char *base, const char *path);
 
+#define DIFF_FORMAT_RAW                0x0001
+#define DIFF_FORMAT_DIFFSTAT   0x0002
+#define DIFF_FORMAT_SUMMARY    0x0004
+#define DIFF_FORMAT_PATCH      0x0008
+
+/* These override all above */
+#define DIFF_FORMAT_NAME       0x0010
+#define DIFF_FORMAT_NAME_STATUS        0x0020
+#define DIFF_FORMAT_CHECKDIFF  0x0040
+
+/* Same as output_format = 0 but we know that -s flag was given
+ * and we should not give default value to output_format.
+ */
+#define DIFF_FORMAT_NO_OUTPUT  0x0080
+
 struct diff_options {
        const char *filter;
        const char *orderfile;
        const char *pickaxe;
        unsigned recursive:1,
-                with_raw:1,
-                with_stat:1,
                 tree_in_recursive:1,
                 binary:1,
                 full_index:1,
                 silent_on_remove:1,
                 find_copies_harder:1,
-                summary:1,
                 color_diff:1;
        int context;
        int break_opt;
@@ -151,15 +163,6 @@ extern void diffcore_std_no_resolve(struct diff_options *);
 "                show all files diff when -S is used and hit is found.\n"
 
 extern int diff_queue_is_empty(void);
-
-#define DIFF_FORMAT_RAW                1
-#define DIFF_FORMAT_PATCH      2
-#define DIFF_FORMAT_NO_OUTPUT  3
-#define DIFF_FORMAT_NAME       4
-#define DIFF_FORMAT_NAME_STATUS        5
-#define DIFF_FORMAT_DIFFSTAT   6
-#define DIFF_FORMAT_CHECKDIFF  7
-
 extern void diff_flush(struct diff_options*);
 
 /* diff-raw status letters */

diff --git a/log-tree.c b/log-tree.c
index ebb49f29701b2435d66eb92fc2a5c382299e8ee8..7d4c51f954f826d95ed922992e55f655be09b912 100644 (file)
--- a/log-tree.c
+++ b/log-tree.c
@@ -163,8 +163,13 @@ int log_tree_diff_flush(struct rev_info *opt)
                return 0;
        }
 
-       if (opt->loginfo && !opt->no_commit_id)
-               show_log(opt, opt->loginfo, opt->diffopt.with_stat ? "---\n" : "\n");
+       if (opt->loginfo && !opt->no_commit_id) {
+               if (opt->diffopt.output_format & DIFF_FORMAT_DIFFSTAT) {
+                       show_log(opt, opt->loginfo,  "---\n");
+               } else {
+                       show_log(opt, opt->loginfo,  "\n");
+               }
+       }
        diff_flush(&opt->diffopt);
        return 1;
 }