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