tests: remove last uses of C_LOCALE_OUTPUT

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

diff --git a/diff-merges.c b/diff-merges.c
index 23e6cb11d1adc68ae881f3326028adc4c26a23cc..146bb50316a6808e381610dc7168a3b7cf638275 100644 (file)
--- a/diff-merges.c
+++ b/diff-merges.c
@@ -4,21 +4,79 @@
 
 static void suppress(struct rev_info *revs)
 {
-       revs->ignore_merges = 1;
+       revs->separate_merges = 0;
        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;
 }
 
-/*
- * Public functions. They are in the order they are called.
- */
+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;
+}
 
-void diff_merges_init_revs(struct rev_info *revs)
+static void set_diff_merges(struct rev_info *revs, const char *optarg)
 {
-       revs->ignore_merges = -1;
+       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.
+ */
+
 int diff_merges_parse_opts(struct rev_info *revs, const char **argv)
 {
        int argcount = 1;
@@ -26,35 +84,23 @@ int diff_merges_parse_opts(struct rev_info *revs, const char **argv)
        const char *arg = argv[0];
 
        if (!strcmp(arg, "-m")) {
-               /*
-                * 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->ignore_merges = 0;
-               revs->match_missing = 1;
+               set_m(revs);
        } else if (!strcmp(arg, "-c")) {
-               revs->diff = 1;
-               revs->dense_combined_merges = 0;
-               revs->combine_merges = 1;
+               set_combined(revs);
+               revs->combined_imply_patch = 1;
        } else if (!strcmp(arg, "--cc")) {
-               revs->diff = 1;
-               revs->dense_combined_merges = 1;
-               revs->combine_merges = 1;
+               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->diff = 1;
                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
-               argcount = 0;
+               return 0;
 
+       revs->explicit_diff_merges = 1;
        return argcount;
 }
 
@@ -65,27 +111,36 @@ void diff_merges_suppress(struct rev_info *revs)
 
 void diff_merges_default_to_first_parent(struct rev_info *revs)
 {
-       if (revs->ignore_merges < 0)            /* No -m */
-               revs->ignore_merges = 0;
+       if (!revs->explicit_diff_merges)
+               revs->separate_merges = 1;
+       if (revs->separate_merges)
+               revs->first_parent_merges = 1;
 }
 
 void diff_merges_default_to_dense_combined(struct rev_info *revs)
 {
-       if (revs->ignore_merges < 0) {          /* No -m */
-               revs->ignore_merges = 0;
-               if (!revs->combine_merges) {    /* No -c/--cc" */
-                       revs->combine_merges = 1;
-                       revs->dense_combined_merges = 1;
-               }
-       }
+       if (!revs->explicit_diff_merges)
+               set_dense_combined(revs);
+}
+
+void diff_merges_set_dense_combined_if_unset(struct rev_info *revs)
+{
+       if (!revs->combine_merges)
+               set_dense_combined(revs);
 }
 
 void diff_merges_setup_revs(struct rev_info *revs)
 {
-       if (revs->combine_merges && revs->ignore_merges < 0)
-               revs->ignore_merges = 0;
-       if (revs->ignore_merges < 0)
-               revs->ignore_merges = 1;
+       if (revs->combine_merges == 0)
+               revs->dense_combined_merges = 0;
+       if (revs->separate_merges == 0)
+               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->combined_imply_patch)
+               revs->diff = 1;
+       if (revs->combined_imply_patch || revs->merges_need_diff) {
+               if (!revs->diffopt.output_format)
+                       revs->diffopt.output_format = DIFF_FORMAT_PATCH;
+       }
 }