test-ctype: macrofy
[git] / submodule.c
1 #include "cache.h"
2 #include "submodule.h"
3 #include "dir.h"
4 #include "diff.h"
5 #include "commit.h"
6 #include "revision.h"
7 #include "run-command.h"
8 #include "diffcore.h"
9 #include "refs.h"
10 #include "string-list.h"
11
12 static struct string_list config_name_for_path;
13 static struct string_list config_fetch_recurse_submodules_for_name;
14 static struct string_list config_ignore_for_name;
15 static int config_fetch_recurse_submodules = RECURSE_SUBMODULES_ON_DEMAND;
16 static struct string_list changed_submodule_paths;
17 /*
18  * The following flag is set if the .gitmodules file is unmerged. We then
19  * disable recursion for all submodules where .git/config doesn't have a
20  * matching config entry because we can't guess what might be configured in
21  * .gitmodules unless the user resolves the conflict. When a command line
22  * option is given (which always overrides configuration) this flag will be
23  * ignored.
24  */
25 static int gitmodules_is_unmerged;
26
27 static int add_submodule_odb(const char *path)
28 {
29         struct strbuf objects_directory = STRBUF_INIT;
30         struct alternate_object_database *alt_odb;
31         int ret = 0;
32         const char *git_dir;
33
34         strbuf_addf(&objects_directory, "%s/.git", path);
35         git_dir = read_gitfile_gently(objects_directory.buf);
36         if (git_dir) {
37                 strbuf_reset(&objects_directory);
38                 strbuf_addstr(&objects_directory, git_dir);
39         }
40         strbuf_addstr(&objects_directory, "/objects/");
41         if (!is_directory(objects_directory.buf)) {
42                 ret = -1;
43                 goto done;
44         }
45         /* avoid adding it twice */
46         for (alt_odb = alt_odb_list; alt_odb; alt_odb = alt_odb->next)
47                 if (alt_odb->name - alt_odb->base == objects_directory.len &&
48                                 !strncmp(alt_odb->base, objects_directory.buf,
49                                         objects_directory.len))
50                         goto done;
51
52         alt_odb = xmalloc(objects_directory.len + 42 + sizeof(*alt_odb));
53         alt_odb->next = alt_odb_list;
54         strcpy(alt_odb->base, objects_directory.buf);
55         alt_odb->name = alt_odb->base + objects_directory.len;
56         alt_odb->name[2] = '/';
57         alt_odb->name[40] = '\0';
58         alt_odb->name[41] = '\0';
59         alt_odb_list = alt_odb;
60         prepare_alt_odb();
61 done:
62         strbuf_release(&objects_directory);
63         return ret;
64 }
65
66 void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
67                                              const char *path)
68 {
69         struct string_list_item *path_option, *ignore_option;
70         path_option = unsorted_string_list_lookup(&config_name_for_path, path);
71         if (path_option) {
72                 ignore_option = unsorted_string_list_lookup(&config_ignore_for_name, path_option->util);
73                 if (ignore_option)
74                         handle_ignore_submodules_arg(diffopt, ignore_option->util);
75                 else if (gitmodules_is_unmerged)
76                         DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
77         }
78 }
79
80 int submodule_config(const char *var, const char *value, void *cb)
81 {
82         if (!prefixcmp(var, "submodule."))
83                 return parse_submodule_config_option(var, value);
84         else if (!strcmp(var, "fetch.recursesubmodules")) {
85                 config_fetch_recurse_submodules = parse_fetch_recurse_submodules_arg(var, value);
86                 return 0;
87         }
88         return 0;
89 }
90
91 void gitmodules_config(void)
92 {
93         const char *work_tree = get_git_work_tree();
94         if (work_tree) {
95                 struct strbuf gitmodules_path = STRBUF_INIT;
96                 int pos;
97                 strbuf_addstr(&gitmodules_path, work_tree);
98                 strbuf_addstr(&gitmodules_path, "/.gitmodules");
99                 if (read_cache() < 0)
100                         die("index file corrupt");
101                 pos = cache_name_pos(".gitmodules", 11);
102                 if (pos < 0) { /* .gitmodules not found or isn't merged */
103                         pos = -1 - pos;
104                         if (active_nr > pos) {  /* there is a .gitmodules */
105                                 const struct cache_entry *ce = active_cache[pos];
106                                 if (ce_namelen(ce) == 11 &&
107                                     !memcmp(ce->name, ".gitmodules", 11))
108                                         gitmodules_is_unmerged = 1;
109                         }
110                 }
111
112                 if (!gitmodules_is_unmerged)
113                         git_config_from_file(submodule_config, gitmodules_path.buf, NULL);
114                 strbuf_release(&gitmodules_path);
115         }
116 }
117
118 int parse_submodule_config_option(const char *var, const char *value)
119 {
120         int len;
121         struct string_list_item *config;
122         struct strbuf submodname = STRBUF_INIT;
123
124         var += 10;              /* Skip "submodule." */
125
126         len = strlen(var);
127         if ((len > 5) && !strcmp(var + len - 5, ".path")) {
128                 strbuf_add(&submodname, var, len - 5);
129                 config = unsorted_string_list_lookup(&config_name_for_path, value);
130                 if (config)
131                         free(config->util);
132                 else
133                         config = string_list_append(&config_name_for_path, xstrdup(value));
134                 config->util = strbuf_detach(&submodname, NULL);
135                 strbuf_release(&submodname);
136         } else if ((len > 23) && !strcmp(var + len - 23, ".fetchrecursesubmodules")) {
137                 strbuf_add(&submodname, var, len - 23);
138                 config = unsorted_string_list_lookup(&config_fetch_recurse_submodules_for_name, submodname.buf);
139                 if (!config)
140                         config = string_list_append(&config_fetch_recurse_submodules_for_name,
141                                                     strbuf_detach(&submodname, NULL));
142                 config->util = (void *)(intptr_t)parse_fetch_recurse_submodules_arg(var, value);
143                 strbuf_release(&submodname);
144         } else if ((len > 7) && !strcmp(var + len - 7, ".ignore")) {
145                 if (strcmp(value, "untracked") && strcmp(value, "dirty") &&
146                     strcmp(value, "all") && strcmp(value, "none")) {
147                         warning("Invalid parameter \"%s\" for config option \"submodule.%s.ignore\"", value, var);
148                         return 0;
149                 }
150
151                 strbuf_add(&submodname, var, len - 7);
152                 config = unsorted_string_list_lookup(&config_ignore_for_name, submodname.buf);
153                 if (config)
154                         free(config->util);
155                 else
156                         config = string_list_append(&config_ignore_for_name,
157                                                     strbuf_detach(&submodname, NULL));
158                 strbuf_release(&submodname);
159                 config->util = xstrdup(value);
160                 return 0;
161         }
162         return 0;
163 }
164
165 void handle_ignore_submodules_arg(struct diff_options *diffopt,
166                                   const char *arg)
167 {
168         DIFF_OPT_CLR(diffopt, IGNORE_SUBMODULES);
169         DIFF_OPT_CLR(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
170         DIFF_OPT_CLR(diffopt, IGNORE_DIRTY_SUBMODULES);
171
172         if (!strcmp(arg, "all"))
173                 DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
174         else if (!strcmp(arg, "untracked"))
175                 DIFF_OPT_SET(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
176         else if (!strcmp(arg, "dirty"))
177                 DIFF_OPT_SET(diffopt, IGNORE_DIRTY_SUBMODULES);
178         else if (strcmp(arg, "none"))
179                 die("bad --ignore-submodules argument: %s", arg);
180 }
181
182 static int prepare_submodule_summary(struct rev_info *rev, const char *path,
183                 struct commit *left, struct commit *right,
184                 int *fast_forward, int *fast_backward)
185 {
186         struct commit_list *merge_bases, *list;
187
188         init_revisions(rev, NULL);
189         setup_revisions(0, NULL, rev, NULL);
190         rev->left_right = 1;
191         rev->first_parent_only = 1;
192         left->object.flags |= SYMMETRIC_LEFT;
193         add_pending_object(rev, &left->object, path);
194         add_pending_object(rev, &right->object, path);
195         merge_bases = get_merge_bases(left, right, 1);
196         if (merge_bases) {
197                 if (merge_bases->item == left)
198                         *fast_forward = 1;
199                 else if (merge_bases->item == right)
200                         *fast_backward = 1;
201         }
202         for (list = merge_bases; list; list = list->next) {
203                 list->item->object.flags |= UNINTERESTING;
204                 add_pending_object(rev, &list->item->object,
205                         sha1_to_hex(list->item->object.sha1));
206         }
207         return prepare_revision_walk(rev);
208 }
209
210 static void print_submodule_summary(struct rev_info *rev, FILE *f,
211                 const char *del, const char *add, const char *reset)
212 {
213         static const char format[] = "  %m %s";
214         struct strbuf sb = STRBUF_INIT;
215         struct commit *commit;
216
217         while ((commit = get_revision(rev))) {
218                 struct pretty_print_context ctx = {0};
219                 ctx.date_mode = rev->date_mode;
220                 strbuf_setlen(&sb, 0);
221                 if (commit->object.flags & SYMMETRIC_LEFT) {
222                         if (del)
223                                 strbuf_addstr(&sb, del);
224                 }
225                 else if (add)
226                         strbuf_addstr(&sb, add);
227                 format_commit_message(commit, format, &sb, &ctx);
228                 if (reset)
229                         strbuf_addstr(&sb, reset);
230                 strbuf_addch(&sb, '\n');
231                 fprintf(f, "%s", sb.buf);
232         }
233         strbuf_release(&sb);
234 }
235
236 int parse_fetch_recurse_submodules_arg(const char *opt, const char *arg)
237 {
238         switch (git_config_maybe_bool(opt, arg)) {
239         case 1:
240                 return RECURSE_SUBMODULES_ON;
241         case 0:
242                 return RECURSE_SUBMODULES_OFF;
243         default:
244                 if (!strcmp(arg, "on-demand"))
245                         return RECURSE_SUBMODULES_ON_DEMAND;
246                 die("bad %s argument: %s", opt, arg);
247         }
248 }
249
250 void show_submodule_summary(FILE *f, const char *path,
251                 unsigned char one[20], unsigned char two[20],
252                 unsigned dirty_submodule,
253                 const char *del, const char *add, const char *reset)
254 {
255         struct rev_info rev;
256         struct commit *left = left, *right = right;
257         const char *message = NULL;
258         struct strbuf sb = STRBUF_INIT;
259         int fast_forward = 0, fast_backward = 0;
260
261         if (is_null_sha1(two))
262                 message = "(submodule deleted)";
263         else if (add_submodule_odb(path))
264                 message = "(not checked out)";
265         else if (is_null_sha1(one))
266                 message = "(new submodule)";
267         else if (!(left = lookup_commit_reference(one)) ||
268                  !(right = lookup_commit_reference(two)))
269                 message = "(commits not present)";
270
271         if (!message &&
272             prepare_submodule_summary(&rev, path, left, right,
273                                         &fast_forward, &fast_backward))
274                 message = "(revision walker failed)";
275
276         if (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED)
277                 fprintf(f, "Submodule %s contains untracked content\n", path);
278         if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
279                 fprintf(f, "Submodule %s contains modified content\n", path);
280
281         if (!hashcmp(one, two)) {
282                 strbuf_release(&sb);
283                 return;
284         }
285
286         strbuf_addf(&sb, "Submodule %s %s..", path,
287                         find_unique_abbrev(one, DEFAULT_ABBREV));
288         if (!fast_backward && !fast_forward)
289                 strbuf_addch(&sb, '.');
290         strbuf_addf(&sb, "%s", find_unique_abbrev(two, DEFAULT_ABBREV));
291         if (message)
292                 strbuf_addf(&sb, " %s\n", message);
293         else
294                 strbuf_addf(&sb, "%s:\n", fast_backward ? " (rewind)" : "");
295         fwrite(sb.buf, sb.len, 1, f);
296
297         if (!message) {
298                 print_submodule_summary(&rev, f, del, add, reset);
299                 clear_commit_marks(left, ~0);
300                 clear_commit_marks(right, ~0);
301         }
302
303         strbuf_release(&sb);
304 }
305
306 void set_config_fetch_recurse_submodules(int value)
307 {
308         config_fetch_recurse_submodules = value;
309 }
310
311 static int is_submodule_commit_present(const char *path, unsigned char sha1[20])
312 {
313         int is_present = 0;
314         if (!add_submodule_odb(path) && lookup_commit_reference(sha1)) {
315                 /* Even if the submodule is checked out and the commit is
316                  * present, make sure it is reachable from a ref. */
317                 struct child_process cp;
318                 const char *argv[] = {"rev-list", "-n", "1", NULL, "--not", "--all", NULL};
319                 struct strbuf buf = STRBUF_INIT;
320
321                 argv[3] = sha1_to_hex(sha1);
322                 memset(&cp, 0, sizeof(cp));
323                 cp.argv = argv;
324                 cp.env = local_repo_env;
325                 cp.git_cmd = 1;
326                 cp.no_stdin = 1;
327                 cp.out = -1;
328                 cp.dir = path;
329                 if (!run_command(&cp) && !strbuf_read(&buf, cp.out, 1024))
330                         is_present = 1;
331
332                 close(cp.out);
333                 strbuf_release(&buf);
334         }
335         return is_present;
336 }
337
338 static void submodule_collect_changed_cb(struct diff_queue_struct *q,
339                                          struct diff_options *options,
340                                          void *data)
341 {
342         int i;
343         for (i = 0; i < q->nr; i++) {
344                 struct diff_filepair *p = q->queue[i];
345                 if (!S_ISGITLINK(p->two->mode))
346                         continue;
347
348                 if (S_ISGITLINK(p->one->mode)) {
349                         /* NEEDSWORK: We should honor the name configured in
350                          * the .gitmodules file of the commit we are examining
351                          * here to be able to correctly follow submodules
352                          * being moved around. */
353                         struct string_list_item *path;
354                         path = unsorted_string_list_lookup(&changed_submodule_paths, p->two->path);
355                         if (!path && !is_submodule_commit_present(p->two->path, p->two->sha1))
356                                 string_list_append(&changed_submodule_paths, xstrdup(p->two->path));
357                 } else {
358                         /* Submodule is new or was moved here */
359                         /* NEEDSWORK: When the .git directories of submodules
360                          * live inside the superprojects .git directory some
361                          * day we should fetch new submodules directly into
362                          * that location too when config or options request
363                          * that so they can be checked out from there. */
364                         continue;
365                 }
366         }
367 }
368
369 void check_for_new_submodule_commits(unsigned char new_sha1[20])
370 {
371         struct rev_info rev;
372         struct commit *commit;
373         const char *argv[] = {NULL, NULL, "--not", "--all", NULL};
374         int argc = ARRAY_SIZE(argv) - 1;
375
376         init_revisions(&rev, NULL);
377         argv[1] = xstrdup(sha1_to_hex(new_sha1));
378         setup_revisions(argc, argv, &rev, NULL);
379         if (prepare_revision_walk(&rev))
380                 die("revision walk setup failed");
381
382         /*
383          * Collect all submodules (whether checked out or not) for which new
384          * commits have been recorded upstream in "changed_submodule_paths".
385          */
386         while ((commit = get_revision(&rev))) {
387                 struct commit_list *parent = commit->parents;
388                 while (parent) {
389                         struct diff_options diff_opts;
390                         diff_setup(&diff_opts);
391                         diff_opts.output_format |= DIFF_FORMAT_CALLBACK;
392                         diff_opts.format_callback = submodule_collect_changed_cb;
393                         if (diff_setup_done(&diff_opts) < 0)
394                                 die("diff_setup_done failed");
395                         diff_tree_sha1(parent->item->object.sha1, commit->object.sha1, "", &diff_opts);
396                         diffcore_std(&diff_opts);
397                         diff_flush(&diff_opts);
398                         parent = parent->next;
399                 }
400         }
401         free((char *)argv[1]);
402 }
403
404 int fetch_populated_submodules(int num_options, const char **options,
405                                const char *prefix, int command_line_option,
406                                int quiet)
407 {
408         int i, result = 0, argc = 0, default_argc;
409         struct child_process cp;
410         const char **argv;
411         struct string_list_item *name_for_path;
412         const char *work_tree = get_git_work_tree();
413         if (!work_tree)
414                 goto out;
415
416         if (!the_index.initialized)
417                 if (read_cache() < 0)
418                         die("index file corrupt");
419
420         /* 6: "fetch" (options) --recurse-submodules-default default "--submodule-prefix" prefix NULL */
421         argv = xcalloc(num_options + 6, sizeof(const char *));
422         argv[argc++] = "fetch";
423         for (i = 0; i < num_options; i++)
424                 argv[argc++] = options[i];
425         argv[argc++] = "--recurse-submodules-default";
426         default_argc = argc++;
427         argv[argc++] = "--submodule-prefix";
428
429         memset(&cp, 0, sizeof(cp));
430         cp.argv = argv;
431         cp.env = local_repo_env;
432         cp.git_cmd = 1;
433         cp.no_stdin = 1;
434
435         for (i = 0; i < active_nr; i++) {
436                 struct strbuf submodule_path = STRBUF_INIT;
437                 struct strbuf submodule_git_dir = STRBUF_INIT;
438                 struct strbuf submodule_prefix = STRBUF_INIT;
439                 struct cache_entry *ce = active_cache[i];
440                 const char *git_dir, *name, *default_argv;
441
442                 if (!S_ISGITLINK(ce->ce_mode))
443                         continue;
444
445                 name = ce->name;
446                 name_for_path = unsorted_string_list_lookup(&config_name_for_path, ce->name);
447                 if (name_for_path)
448                         name = name_for_path->util;
449
450                 default_argv = "yes";
451                 if (command_line_option == RECURSE_SUBMODULES_DEFAULT) {
452                         struct string_list_item *fetch_recurse_submodules_option;
453                         fetch_recurse_submodules_option = unsorted_string_list_lookup(&config_fetch_recurse_submodules_for_name, name);
454                         if (fetch_recurse_submodules_option) {
455                                 if ((intptr_t)fetch_recurse_submodules_option->util == RECURSE_SUBMODULES_OFF)
456                                         continue;
457                                 if ((intptr_t)fetch_recurse_submodules_option->util == RECURSE_SUBMODULES_ON_DEMAND) {
458                                         if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
459                                                 continue;
460                                         default_argv = "on-demand";
461                                 }
462                         } else {
463                                 if ((config_fetch_recurse_submodules == RECURSE_SUBMODULES_OFF) ||
464                                     gitmodules_is_unmerged)
465                                         continue;
466                                 if (config_fetch_recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND) {
467                                         if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
468                                                 continue;
469                                         default_argv = "on-demand";
470                                 }
471                         }
472                 } else if (command_line_option == RECURSE_SUBMODULES_ON_DEMAND) {
473                         if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
474                                 continue;
475                         default_argv = "on-demand";
476                 }
477
478                 strbuf_addf(&submodule_path, "%s/%s", work_tree, ce->name);
479                 strbuf_addf(&submodule_git_dir, "%s/.git", submodule_path.buf);
480                 strbuf_addf(&submodule_prefix, "%s%s/", prefix, ce->name);
481                 git_dir = read_gitfile_gently(submodule_git_dir.buf);
482                 if (!git_dir)
483                         git_dir = submodule_git_dir.buf;
484                 if (is_directory(git_dir)) {
485                         if (!quiet)
486                                 printf("Fetching submodule %s%s\n", prefix, ce->name);
487                         cp.dir = submodule_path.buf;
488                         argv[default_argc] = default_argv;
489                         argv[argc] = submodule_prefix.buf;
490                         if (run_command(&cp))
491                                 result = 1;
492                 }
493                 strbuf_release(&submodule_path);
494                 strbuf_release(&submodule_git_dir);
495                 strbuf_release(&submodule_prefix);
496         }
497         free(argv);
498 out:
499         string_list_clear(&changed_submodule_paths, 1);
500         return result;
501 }
502
503 unsigned is_submodule_modified(const char *path, int ignore_untracked)
504 {
505         ssize_t len;
506         struct child_process cp;
507         const char *argv[] = {
508                 "status",
509                 "--porcelain",
510                 NULL,
511                 NULL,
512         };
513         struct strbuf buf = STRBUF_INIT;
514         unsigned dirty_submodule = 0;
515         const char *line, *next_line;
516         const char *git_dir;
517
518         strbuf_addf(&buf, "%s/.git", path);
519         git_dir = read_gitfile_gently(buf.buf);
520         if (!git_dir)
521                 git_dir = buf.buf;
522         if (!is_directory(git_dir)) {
523                 strbuf_release(&buf);
524                 /* The submodule is not checked out, so it is not modified */
525                 return 0;
526
527         }
528         strbuf_reset(&buf);
529
530         if (ignore_untracked)
531                 argv[2] = "-uno";
532
533         memset(&cp, 0, sizeof(cp));
534         cp.argv = argv;
535         cp.env = local_repo_env;
536         cp.git_cmd = 1;
537         cp.no_stdin = 1;
538         cp.out = -1;
539         cp.dir = path;
540         if (start_command(&cp))
541                 die("Could not run git status --porcelain");
542
543         len = strbuf_read(&buf, cp.out, 1024);
544         line = buf.buf;
545         while (len > 2) {
546                 if ((line[0] == '?') && (line[1] == '?')) {
547                         dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
548                         if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
549                                 break;
550                 } else {
551                         dirty_submodule |= DIRTY_SUBMODULE_MODIFIED;
552                         if (ignore_untracked ||
553                             (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED))
554                                 break;
555                 }
556                 next_line = strchr(line, '\n');
557                 if (!next_line)
558                         break;
559                 next_line++;
560                 len -= (next_line - line);
561                 line = next_line;
562         }
563         close(cp.out);
564
565         if (finish_command(&cp))
566                 die("git status --porcelain failed");
567
568         strbuf_release(&buf);
569         return dirty_submodule;
570 }
571
572 static int find_first_merges(struct object_array *result, const char *path,
573                 struct commit *a, struct commit *b)
574 {
575         int i, j;
576         struct object_array merges;
577         struct commit *commit;
578         int contains_another;
579
580         char merged_revision[42];
581         const char *rev_args[] = { "rev-list", "--merges", "--ancestry-path",
582                                    "--all", merged_revision, NULL };
583         struct rev_info revs;
584         struct setup_revision_opt rev_opts;
585
586         memset(&merges, 0, sizeof(merges));
587         memset(result, 0, sizeof(struct object_array));
588         memset(&rev_opts, 0, sizeof(rev_opts));
589
590         /* get all revisions that merge commit a */
591         snprintf(merged_revision, sizeof(merged_revision), "^%s",
592                         sha1_to_hex(a->object.sha1));
593         init_revisions(&revs, NULL);
594         rev_opts.submodule = path;
595         setup_revisions(sizeof(rev_args)/sizeof(char *)-1, rev_args, &revs, &rev_opts);
596
597         /* save all revisions from the above list that contain b */
598         if (prepare_revision_walk(&revs))
599                 die("revision walk setup failed");
600         while ((commit = get_revision(&revs)) != NULL) {
601                 struct object *o = &(commit->object);
602                 if (in_merge_bases(b, &commit, 1))
603                         add_object_array(o, NULL, &merges);
604         }
605
606         /* Now we've got all merges that contain a and b. Prune all
607          * merges that contain another found merge and save them in
608          * result.
609          */
610         for (i = 0; i < merges.nr; i++) {
611                 struct commit *m1 = (struct commit *) merges.objects[i].item;
612
613                 contains_another = 0;
614                 for (j = 0; j < merges.nr; j++) {
615                         struct commit *m2 = (struct commit *) merges.objects[j].item;
616                         if (i != j && in_merge_bases(m2, &m1, 1)) {
617                                 contains_another = 1;
618                                 break;
619                         }
620                 }
621
622                 if (!contains_another)
623                         add_object_array(merges.objects[i].item,
624                                          merges.objects[i].name, result);
625         }
626
627         free(merges.objects);
628         return result->nr;
629 }
630
631 static void print_commit(struct commit *commit)
632 {
633         struct strbuf sb = STRBUF_INIT;
634         struct pretty_print_context ctx = {0};
635         ctx.date_mode = DATE_NORMAL;
636         format_commit_message(commit, " %h: %m %s", &sb, &ctx);
637         fprintf(stderr, "%s\n", sb.buf);
638         strbuf_release(&sb);
639 }
640
641 #define MERGE_WARNING(path, msg) \
642         warning("Failed to merge submodule %s (%s)", path, msg);
643
644 int merge_submodule(unsigned char result[20], const char *path,
645                     const unsigned char base[20], const unsigned char a[20],
646                     const unsigned char b[20])
647 {
648         struct commit *commit_base, *commit_a, *commit_b;
649         int parent_count;
650         struct object_array merges;
651
652         int i;
653
654         /* store a in result in case we fail */
655         hashcpy(result, a);
656
657         /* we can not handle deletion conflicts */
658         if (is_null_sha1(base))
659                 return 0;
660         if (is_null_sha1(a))
661                 return 0;
662         if (is_null_sha1(b))
663                 return 0;
664
665         if (add_submodule_odb(path)) {
666                 MERGE_WARNING(path, "not checked out");
667                 return 0;
668         }
669
670         if (!(commit_base = lookup_commit_reference(base)) ||
671             !(commit_a = lookup_commit_reference(a)) ||
672             !(commit_b = lookup_commit_reference(b))) {
673                 MERGE_WARNING(path, "commits not present");
674                 return 0;
675         }
676
677         /* check whether both changes are forward */
678         if (!in_merge_bases(commit_base, &commit_a, 1) ||
679             !in_merge_bases(commit_base, &commit_b, 1)) {
680                 MERGE_WARNING(path, "commits don't follow merge-base");
681                 return 0;
682         }
683
684         /* Case #1: a is contained in b or vice versa */
685         if (in_merge_bases(commit_a, &commit_b, 1)) {
686                 hashcpy(result, b);
687                 return 1;
688         }
689         if (in_merge_bases(commit_b, &commit_a, 1)) {
690                 hashcpy(result, a);
691                 return 1;
692         }
693
694         /*
695          * Case #2: There are one or more merges that contain a and b in
696          * the submodule. If there is only one, then present it as a
697          * suggestion to the user, but leave it marked unmerged so the
698          * user needs to confirm the resolution.
699          */
700
701         /* find commit which merges them */
702         parent_count = find_first_merges(&merges, path, commit_a, commit_b);
703         switch (parent_count) {
704         case 0:
705                 MERGE_WARNING(path, "merge following commits not found");
706                 break;
707
708         case 1:
709                 MERGE_WARNING(path, "not fast-forward");
710                 fprintf(stderr, "Found a possible merge resolution "
711                                 "for the submodule:\n");
712                 print_commit((struct commit *) merges.objects[0].item);
713                 fprintf(stderr,
714                         "If this is correct simply add it to the index "
715                         "for example\n"
716                         "by using:\n\n"
717                         "  git update-index --cacheinfo 160000 %s \"%s\"\n\n"
718                         "which will accept this suggestion.\n",
719                         sha1_to_hex(merges.objects[0].item->sha1), path);
720                 break;
721
722         default:
723                 MERGE_WARNING(path, "multiple merges found");
724                 for (i = 0; i < merges.nr; i++)
725                         print_commit((struct commit *) merges.objects[i].item);
726         }
727
728         free(merges.objects);
729         return 0;
730 }