diff-merges.c

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