diff-merges.c

   1 #include "diff-merges.h"
   2
   3 #include "revision.h"
   4
   5 typedef void (*diff_merges_setup_func_t)(struct rev_info *);
   6 static void set_separate(struct rev_info *revs);
   7
   8 static diff_merges_setup_func_t set_to_default = set_separate;
   9 static int suppress_m_parsing;
  10
  11 static void suppress(struct rev_info *revs)
  12 {
  13         revs->separate_merges = 0;
  14         revs->first_parent_merges = 0;
  15         revs->combine_merges = 0;
  16         revs->dense_combined_merges = 0;
  17         revs->combined_all_paths = 0;
  18         revs->merges_imply_patch = 0;
  19         revs->merges_need_diff = 0;
  20         revs->remerge_diff = 0;
  21 }
  22
  23 static void set_separate(struct rev_info *revs)
  24 {
  25         suppress(revs);
  26         revs->separate_merges = 1;
  27         revs->simplify_history = 0;
  28 }
  29
  30 static void set_first_parent(struct rev_info *revs)
  31 {
  32         set_separate(revs);
  33         revs->first_parent_merges = 1;
  34 }
  35
  36 static void set_combined(struct rev_info *revs)
  37 {
  38         suppress(revs);
  39         revs->combine_merges = 1;
  40         revs->dense_combined_merges = 0;
  41 }
  42
  43 static void set_dense_combined(struct rev_info *revs)
  44 {
  45         suppress(revs);
  46         revs->combine_merges = 1;
  47         revs->dense_combined_merges = 1;
  48 }
  49
  50 static void set_remerge_diff(struct rev_info *revs)
  51 {
  52         suppress(revs);
  53         revs->remerge_diff = 1;
  54         revs->simplify_history = 0;
  55 }
  56
  57 static diff_merges_setup_func_t func_by_opt(const char *optarg)
  58 {
  59         if (!strcmp(optarg, "off") || !strcmp(optarg, "none"))
  60                 return suppress;
  61         if (!strcmp(optarg, "1") || !strcmp(optarg, "first-parent"))
  62                 return set_first_parent;
  63         else if (!strcmp(optarg, "separate"))
  64                 return set_separate;
  65         else if (!strcmp(optarg, "c") || !strcmp(optarg, "combined"))
  66                 return set_combined;
  67         else if (!strcmp(optarg, "cc") || !strcmp(optarg, "dense-combined"))
  68                 return set_dense_combined;
  69         else if (!strcmp(optarg, "r") || !strcmp(optarg, "remerge"))
  70                 return set_remerge_diff;
  71         else if (!strcmp(optarg, "m") || !strcmp(optarg, "on"))
  72                 return set_to_default;
  73         return NULL;
  74 }
  75
  76 static void set_diff_merges(struct rev_info *revs, const char *optarg)
  77 {
  78         diff_merges_setup_func_t func = func_by_opt(optarg);
  79
  80         if (!func)
  81                 die(_("unknown value for --diff-merges: %s"), optarg);
  82
  83         func(revs);
  84
  85         /* NOTE: the merges_need_diff flag is cleared by func() call */
  86         if (func != suppress)
  87                 revs->merges_need_diff = 1;
  88 }
  89
  90 /*
  91  * Public functions. They are in the order they are called.
  92  */
  93
  94 int diff_merges_config(const char *value)
  95 {
  96         diff_merges_setup_func_t func = func_by_opt(value);
  97
  98         if (!func)
  99                 return -1;
 100
 101         set_to_default = func;
 102         return 0;
 103 }
 104
 105 void diff_merges_suppress_m_parsing(void)
 106 {
 107         suppress_m_parsing = 1;
 108 }
 109
 110 int diff_merges_parse_opts(struct rev_info *revs, const char **argv)
 111 {
 112         int argcount = 1;
 113         const char *optarg;
 114         const char *arg = argv[0];
 115
 116         if (!suppress_m_parsing && !strcmp(arg, "-m")) {
 117                 set_to_default(revs);
 118         } else if (!strcmp(arg, "-c")) {
 119                 set_combined(revs);
 120                 revs->merges_imply_patch = 1;
 121         } else if (!strcmp(arg, "--cc")) {
 122                 set_dense_combined(revs);
 123                 revs->merges_imply_patch = 1;
 124         } else if (!strcmp(arg, "--remerge-diff")) {
 125                 set_remerge_diff(revs);
 126                 revs->merges_imply_patch = 1;
 127         } else if (!strcmp(arg, "--no-diff-merges")) {
 128                 suppress(revs);
 129         } else if (!strcmp(arg, "--combined-all-paths")) {
 130                 revs->combined_all_paths = 1;
 131         } else if ((argcount = parse_long_opt("diff-merges", argv, &optarg))) {
 132                 set_diff_merges(revs, optarg);
 133         } else
 134                 return 0;
 135
 136         revs->explicit_diff_merges = 1;
 137         return argcount;
 138 }
 139
 140 void diff_merges_suppress(struct rev_info *revs)
 141 {
 142         suppress(revs);
 143 }
 144
 145 void diff_merges_default_to_first_parent(struct rev_info *revs)
 146 {
 147         if (!revs->explicit_diff_merges)
 148                 revs->separate_merges = 1;
 149         if (revs->separate_merges)
 150                 revs->first_parent_merges = 1;
 151 }
 152
 153 void diff_merges_default_to_dense_combined(struct rev_info *revs)
 154 {
 155         if (!revs->explicit_diff_merges)
 156                 set_dense_combined(revs);
 157 }
 158
 159 void diff_merges_set_dense_combined_if_unset(struct rev_info *revs)
 160 {
 161         if (!revs->combine_merges)
 162                 set_dense_combined(revs);
 163 }
 164
 165 void diff_merges_setup_revs(struct rev_info *revs)
 166 {
 167         if (revs->combine_merges == 0)
 168                 revs->dense_combined_merges = 0;
 169         if (revs->separate_merges == 0)
 170                 revs->first_parent_merges = 0;
 171         if (revs->combined_all_paths && !revs->combine_merges)
 172                 die("--combined-all-paths makes no sense without -c or --cc");
 173         if (revs->merges_imply_patch)
 174                 revs->diff = 1;
 175         if (revs->merges_imply_patch || revs->merges_need_diff) {
 176                 if (!revs->diffopt.output_format)
 177                         revs->diffopt.output_format = DIFF_FORMAT_PATCH;
 178         }
 179 }