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_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_options_parsing(void)
  95 {
  96         suppress_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_parsing)
 106                 return 0;
 107
 108         if (!strcmp(arg, "-m")) {
 109                 set_to_default(revs);
 110         } else if (!strcmp(arg, "-c")) {
 111                 set_combined(revs);
 112                 revs->merges_imply_patch = 1;
 113         } else if (!strcmp(arg, "--cc")) {
 114                 set_dense_combined(revs);
 115                 revs->merges_imply_patch = 1;
 116         } else if (!strcmp(arg, "--no-diff-merges")) {
 117                 suppress(revs);
 118         } else if (!strcmp(arg, "--combined-all-paths")) {
 119                 revs->combined_all_paths = 1;
 120         } else if ((argcount = parse_long_opt("diff-merges", argv, &optarg))) {
 121                 set_diff_merges(revs, optarg);
 122         } else
 123                 return 0;
 124
 125         revs->explicit_diff_merges = 1;
 126         return argcount;
 127 }
 128
 129 void diff_merges_suppress(struct rev_info *revs)
 130 {
 131         suppress(revs);
 132 }
 133
 134 void diff_merges_default_to_first_parent(struct rev_info *revs)
 135 {
 136         if (!revs->explicit_diff_merges)
 137                 revs->separate_merges = 1;
 138         if (revs->separate_merges)
 139                 revs->first_parent_merges = 1;
 140 }
 141
 142 void diff_merges_default_to_dense_combined(struct rev_info *revs)
 143 {
 144         if (!revs->explicit_diff_merges)
 145                 set_dense_combined(revs);
 146 }
 147
 148 void diff_merges_set_dense_combined_if_unset(struct rev_info *revs)
 149 {
 150         if (!revs->combine_merges)
 151                 set_dense_combined(revs);
 152 }
 153
 154 void diff_merges_setup_revs(struct rev_info *revs)
 155 {
 156         if (suppress_parsing)
 157                 return;
 158
 159         if (revs->combine_merges == 0)
 160                 revs->dense_combined_merges = 0;
 161         if (revs->separate_merges == 0)
 162                 revs->first_parent_merges = 0;
 163         if (revs->combined_all_paths && !revs->combine_merges)
 164                 die("--combined-all-paths makes no sense without -c or --cc");
 165         if (revs->merges_imply_patch)
 166                 revs->diff = 1;
 167         if (revs->merges_imply_patch || revs->merges_need_diff) {
 168                 if (!revs->diffopt.output_format)
 169                         revs->diffopt.output_format = DIFF_FORMAT_PATCH;
 170         }
 171 }