Merge branch 'js/params-vs-args'

[thirdparty/git.git] / diff-merges.c

diff --git a/diff-merges.c b/diff-merges.c
index 34d7ed7c70b70bd07ce0555b02576047caf06336..146bb50316a6808e381610dc7168a3b7cf638275 100644 (file)
--- a/diff-merges.c
+++ b/diff-merges.c
@@ -8,14 +8,70 @@ static void suppress(struct rev_info *revs)
        revs->first_parent_merges = 0;
        revs->combine_merges = 0;
        revs->dense_combined_merges = 0;
+       revs->combined_all_paths = 0;
+       revs->combined_imply_patch = 0;
+       revs->merges_need_diff = 0;
+}
+
+static void set_separate(struct rev_info *revs)
+{
+       suppress(revs);
+       revs->separate_merges = 1;
+}
+
+static void set_first_parent(struct rev_info *revs)
+{
+       set_separate(revs);
+       revs->first_parent_merges = 1;
+}
+
+static void set_m(struct rev_info *revs)
+{
+       /*
+        * To "diff-index", "-m" means "match missing", and to the "log"
+        * family of commands, it means "show full diff for merges". Set
+        * both fields appropriately.
+        */
+       set_separate(revs);
+       revs->match_missing = 1;
+}
+
+static void set_combined(struct rev_info *revs)
+{
+       suppress(revs);
+       revs->combine_merges = 1;
+       revs->dense_combined_merges = 0;
 }
 
 static void set_dense_combined(struct rev_info *revs)
 {
+       suppress(revs);
        revs->combine_merges = 1;
        revs->dense_combined_merges = 1;
 }
 
+static void set_diff_merges(struct rev_info *revs, const char *optarg)
+{
+       if (!strcmp(optarg, "off") || !strcmp(optarg, "none")) {
+               suppress(revs);
+               /* Return early to leave revs->merges_need_diff unset */
+               return;
+       }
+
+       if (!strcmp(optarg, "1") || !strcmp(optarg, "first-parent"))
+               set_first_parent(revs);
+       else if (!strcmp(optarg, "m") || !strcmp(optarg, "separate"))
+               set_separate(revs);
+       else if (!strcmp(optarg, "c") || !strcmp(optarg, "combined"))
+               set_combined(revs);
+       else if (!strcmp(optarg, "cc") || !strcmp(optarg, "dense-combined"))
+               set_dense_combined(revs);
+       else
+               die(_("unknown value for --diff-merges: %s"), optarg);
+
+       /* The flag is cleared by set_xxx() functions, so don't move this up */
+       revs->merges_need_diff = 1;
+}
 
 /*
  * Public functions. They are in the order they are called.
@@ -28,29 +84,19 @@ int diff_merges_parse_opts(struct rev_info *revs, const char **argv)
        const char *arg = argv[0];
 
        if (!strcmp(arg, "-m")) {
-               suppress(revs);
-               /*
-                * To "diff-index", "-m" means "match missing", and to the "log"
-                * family of commands, it means "show full diff for merges". Set
-                * both fields appropriately.
-                */
-               revs->separate_merges = 1;
-               revs->match_missing = 1;
+               set_m(revs);
        } else if (!strcmp(arg, "-c")) {
-               revs->dense_combined_merges = 0;
-               revs->combine_merges = 1;
+               set_combined(revs);
+               revs->combined_imply_patch = 1;
        } else if (!strcmp(arg, "--cc")) {
                set_dense_combined(revs);
+               revs->combined_imply_patch = 1;
        } else if (!strcmp(arg, "--no-diff-merges")) {
                suppress(revs);
        } else if (!strcmp(arg, "--combined-all-paths")) {
                revs->combined_all_paths = 1;
        } else if ((argcount = parse_long_opt("diff-merges", argv, &optarg))) {
-               if (!strcmp(optarg, "off")) {
-                       suppress(revs);
-               } else {
-                       die(_("unknown value for --diff-merges: %s"), optarg);
-               }
+               set_diff_merges(revs, optarg);
        } else
                return 0;
 
@@ -91,9 +137,9 @@ void diff_merges_setup_revs(struct rev_info *revs)
                revs->first_parent_merges = 0;
        if (revs->combined_all_paths && !revs->combine_merges)
                die("--combined-all-paths makes no sense without -c or --cc");
-       if (revs->combine_merges) {
+       if (revs->combined_imply_patch)
                revs->diff = 1;
-               /* Turn --cc/-c into -p --cc/-c when -p was not given */
+       if (revs->combined_imply_patch || revs->merges_need_diff) {
                if (!revs->diffopt.output_format)
                        revs->diffopt.output_format = DIFF_FORMAT_PATCH;
        }