![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
1 /*
2 * Builtin "git commit"
3 *
4 * Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>
5 * Based on git-commit.sh by Junio C Hamano and Linus Torvalds
6 */
8 #include "cache.h"
9 #include "cache-tree.h"
10 #include "color.h"
11 #include "dir.h"
12 #include "builtin.h"
13 #include "diff.h"
14 #include "diffcore.h"
15 #include "commit.h"
16 #include "revision.h"
17 #include "wt-status.h"
18 #include "run-command.h"
19 #include "refs.h"
20 #include "log-tree.h"
21 #include "strbuf.h"
22 #include "utf8.h"
23 #include "parse-options.h"
24 #include "string-list.h"
25 #include "rerere.h"
26 #include "unpack-trees.h"
27 #include "quote.h"
28 #include "submodule.h"
30 static const char * const builtin_commit_usage[] = {
31 "git commit [options] [--] <filepattern>...",
32 NULL
33 };
35 static const char * const builtin_status_usage[] = {
36 "git status [options] [--] <filepattern>...",
37 NULL
38 };
40 static const char implicit_ident_advice[] =
41 "Your name and email address were configured automatically based\n"
42 "on your username and hostname. Please check that they are accurate.\n"
43 "You can suppress this message by setting them explicitly:\n"
44 "\n"
45 " git config --global user.name \"Your Name\"\n"
46 " git config --global user.email you@example.com\n"
47 "\n"
48 "After doing this, you may fix the identity used for this commit with:\n"
49 "\n"
50 " git commit --amend --reset-author\n";
52 static const char empty_amend_advice[] =
53 "You asked to amend the most recent commit, but doing so would make\n"
54 "it empty. You can repeat your command with --allow-empty, or you can\n"
55 "remove the commit entirely with \"git reset HEAD^\".\n";
57 static const char empty_cherry_pick_advice[] =
58 "The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
59 "If you wish to commit it anyway, use:\n"
60 "\n"
61 " git commit --allow-empty\n"
62 "\n"
63 "Otherwise, please use 'git reset'\n";
65 static unsigned char head_sha1[20];
67 static const char *use_message_buffer;
68 static const char commit_editmsg[] = "COMMIT_EDITMSG";
69 static struct lock_file index_lock; /* real index */
70 static struct lock_file false_lock; /* used only for partial commits */
71 static enum {
72 COMMIT_AS_IS = 1,
73 COMMIT_NORMAL,
74 COMMIT_PARTIAL
75 } commit_style;
77 static const char *logfile, *force_author;
78 static const char *template_file;
79 /*
80 * The _message variables are commit names from which to take
81 * the commit message and/or authorship.
82 */
83 static const char *author_message, *author_message_buffer;
84 static char *edit_message, *use_message;
85 static char *fixup_message, *squash_message;
86 static int all, edit_flag, also, interactive, only, amend, signoff;
87 static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
88 static int no_post_rewrite, allow_empty_message;
89 static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
90 /*
91 * The default commit message cleanup mode will remove the lines
92 * beginning with # (shell comments) and leading and trailing
93 * whitespaces (empty lines or containing only whitespaces)
94 * if editor is used, and only the whitespaces if the message
95 * is specified explicitly.
96 */
97 static enum {
98 CLEANUP_SPACE,
99 CLEANUP_NONE,
100 CLEANUP_ALL
101 } cleanup_mode;
102 static char *cleanup_arg;
104 static enum commit_whence whence;
105 static int use_editor = 1, initial_commit, include_status = 1;
106 static int show_ignored_in_status;
107 static const char *only_include_assumed;
108 static struct strbuf message;
110 static int null_termination;
111 static enum {
112 STATUS_FORMAT_LONG,
113 STATUS_FORMAT_SHORT,
114 STATUS_FORMAT_PORCELAIN
115 } status_format = STATUS_FORMAT_LONG;
116 static int status_show_branch;
118 static int opt_parse_m(const struct option *opt, const char *arg, int unset)
119 {
120 struct strbuf *buf = opt->value;
121 if (unset)
122 strbuf_setlen(buf, 0);
123 else {
124 strbuf_addstr(buf, arg);
125 strbuf_addstr(buf, "\n\n");
126 }
127 return 0;
128 }
130 static struct option builtin_commit_options[] = {
131 OPT__QUIET(&quiet, "suppress summary after successful commit"),
132 OPT__VERBOSE(&verbose, "show diff in commit message template"),
134 OPT_GROUP("Commit message options"),
135 OPT_FILENAME('F', "file", &logfile, "read message from file"),
136 OPT_STRING(0, "author", &force_author, "author", "override author for commit"),
137 OPT_STRING(0, "date", &force_date, "date", "override date for commit"),
138 OPT_CALLBACK('m', "message", &message, "message", "commit message", opt_parse_m),
139 OPT_STRING('c', "reedit-message", &edit_message, "commit", "reuse and edit message from specified commit"),
140 OPT_STRING('C', "reuse-message", &use_message, "commit", "reuse message from specified commit"),
141 OPT_STRING(0, "fixup", &fixup_message, "commit", "use autosquash formatted message to fixup specified commit"),
142 OPT_STRING(0, "squash", &squash_message, "commit", "use autosquash formatted message to squash specified commit"),
143 OPT_BOOLEAN(0, "reset-author", &renew_authorship, "the commit is authored by me now (used with -C-c/--amend)"),
144 OPT_BOOLEAN('s', "signoff", &signoff, "add Signed-off-by:"),
145 OPT_FILENAME('t', "template", &template_file, "use specified template file"),
146 OPT_BOOLEAN('e', "edit", &edit_flag, "force edit of commit"),
147 OPT_STRING(0, "cleanup", &cleanup_arg, "default", "how to strip spaces and #comments from message"),
148 OPT_BOOLEAN(0, "status", &include_status, "include status in commit message template"),
149 /* end commit message options */
151 OPT_GROUP("Commit contents options"),
152 OPT_BOOLEAN('a', "all", &all, "commit all changed files"),
153 OPT_BOOLEAN('i', "include", &also, "add specified files to index for commit"),
154 OPT_BOOLEAN(0, "interactive", &interactive, "interactively add files"),
155 OPT_BOOLEAN('o', "only", &only, "commit only specified files"),
156 OPT_BOOLEAN('n', "no-verify", &no_verify, "bypass pre-commit hook"),
157 OPT_BOOLEAN(0, "dry-run", &dry_run, "show what would be committed"),
158 OPT_SET_INT(0, "short", &status_format, "show status concisely",
159 STATUS_FORMAT_SHORT),
160 OPT_BOOLEAN(0, "branch", &status_show_branch, "show branch information"),
161 OPT_SET_INT(0, "porcelain", &status_format,
162 "machine-readable output", STATUS_FORMAT_PORCELAIN),
163 OPT_BOOLEAN('z', "null", &null_termination,
164 "terminate entries with NUL"),
165 OPT_BOOLEAN(0, "amend", &amend, "amend previous commit"),
166 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite, "bypass post-rewrite hook"),
167 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg, "mode", "show untracked files, optional modes: all, normal, no. (Default: all)", PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
168 /* end commit contents options */
170 { OPTION_BOOLEAN, 0, "allow-empty", &allow_empty, NULL,
171 "ok to record an empty change",
172 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
173 { OPTION_BOOLEAN, 0, "allow-empty-message", &allow_empty_message, NULL,
174 "ok to record a change with an empty message",
175 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
177 OPT_END()
178 };
180 static void determine_whence(struct wt_status *s)
181 {
182 if (file_exists(git_path("MERGE_HEAD")))
183 whence = FROM_MERGE;
184 else if (file_exists(git_path("CHERRY_PICK_HEAD")))
185 whence = FROM_CHERRY_PICK;
186 else
187 whence = FROM_COMMIT;
188 if (s)
189 s->whence = whence;
190 }
192 static const char *whence_s(void)
193 {
194 char *s = "";
196 switch (whence) {
197 case FROM_COMMIT:
198 break;
199 case FROM_MERGE:
200 s = "merge";
201 break;
202 case FROM_CHERRY_PICK:
203 s = "cherry-pick";
204 break;
205 }
207 return s;
208 }
210 static void rollback_index_files(void)
211 {
212 switch (commit_style) {
213 case COMMIT_AS_IS:
214 break; /* nothing to do */
215 case COMMIT_NORMAL:
216 rollback_lock_file(&index_lock);
217 break;
218 case COMMIT_PARTIAL:
219 rollback_lock_file(&index_lock);
220 rollback_lock_file(&false_lock);
221 break;
222 }
223 }
225 static int commit_index_files(void)
226 {
227 int err = 0;
229 switch (commit_style) {
230 case COMMIT_AS_IS:
231 break; /* nothing to do */
232 case COMMIT_NORMAL:
233 err = commit_lock_file(&index_lock);
234 break;
235 case COMMIT_PARTIAL:
236 err = commit_lock_file(&index_lock);
237 rollback_lock_file(&false_lock);
238 break;
239 }
241 return err;
242 }
244 /*
245 * Take a union of paths in the index and the named tree (typically, "HEAD"),
246 * and return the paths that match the given pattern in list.
247 */
248 static int list_paths(struct string_list *list, const char *with_tree,
249 const char *prefix, const char **pattern)
250 {
251 int i;
252 char *m;
254 for (i = 0; pattern[i]; i++)
255 ;
256 m = xcalloc(1, i);
258 if (with_tree)
259 overlay_tree_on_cache(with_tree, prefix);
261 for (i = 0; i < active_nr; i++) {
262 struct cache_entry *ce = active_cache[i];
263 struct string_list_item *item;
265 if (ce->ce_flags & CE_UPDATE)
266 continue;
267 if (!match_pathspec(pattern, ce->name, ce_namelen(ce), 0, m))
268 continue;
269 item = string_list_insert(list, ce->name);
270 if (ce_skip_worktree(ce))
271 item->util = item; /* better a valid pointer than a fake one */
272 }
274 return report_path_error(m, pattern, prefix ? strlen(prefix) : 0);
275 }
277 static void add_remove_files(struct string_list *list)
278 {
279 int i;
280 for (i = 0; i < list->nr; i++) {
281 struct stat st;
282 struct string_list_item *p = &(list->items[i]);
284 /* p->util is skip-worktree */
285 if (p->util)
286 continue;
288 if (!lstat(p->string, &st)) {
289 if (add_to_cache(p->string, &st, 0))
290 die("updating files failed");
291 } else
292 remove_file_from_cache(p->string);
293 }
294 }
296 static void create_base_index(void)
297 {
298 struct tree *tree;
299 struct unpack_trees_options opts;
300 struct tree_desc t;
302 if (initial_commit) {
303 discard_cache();
304 return;
305 }
307 memset(&opts, 0, sizeof(opts));
308 opts.head_idx = 1;
309 opts.index_only = 1;
310 opts.merge = 1;
311 opts.src_index = &the_index;
312 opts.dst_index = &the_index;
314 opts.fn = oneway_merge;
315 tree = parse_tree_indirect(head_sha1);
316 if (!tree)
317 die("failed to unpack HEAD tree object");
318 parse_tree(tree);
319 init_tree_desc(&t, tree->buffer, tree->size);
320 if (unpack_trees(1, &t, &opts))
321 exit(128); /* We've already reported the error, finish dying */
322 }
324 static void refresh_cache_or_die(int refresh_flags)
325 {
326 /*
327 * refresh_flags contains REFRESH_QUIET, so the only errors
328 * are for unmerged entries.
329 */
330 if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
331 die_resolve_conflict("commit");
332 }
334 static char *prepare_index(int argc, const char **argv, const char *prefix, int is_status)
335 {
336 int fd;
337 struct string_list partial;
338 const char **pathspec = NULL;
339 int refresh_flags = REFRESH_QUIET;
341 if (is_status)
342 refresh_flags |= REFRESH_UNMERGED;
343 if (interactive) {
344 if (interactive_add(argc, argv, prefix) != 0)
345 die("interactive add failed");
346 if (read_cache_preload(NULL) < 0)
347 die("index file corrupt");
348 commit_style = COMMIT_AS_IS;
349 return get_index_file();
350 }
352 if (*argv)
353 pathspec = get_pathspec(prefix, argv);
355 if (read_cache_preload(pathspec) < 0)
356 die("index file corrupt");
358 /*
359 * Non partial, non as-is commit.
360 *
361 * (1) get the real index;
362 * (2) update the_index as necessary;
363 * (3) write the_index out to the real index (still locked);
364 * (4) return the name of the locked index file.
365 *
366 * The caller should run hooks on the locked real index, and
367 * (A) if all goes well, commit the real index;
368 * (B) on failure, rollback the real index.
369 */
370 if (all || (also && pathspec && *pathspec)) {
371 fd = hold_locked_index(&index_lock, 1);
372 add_files_to_cache(also ? prefix : NULL, pathspec, 0);
373 refresh_cache_or_die(refresh_flags);
374 if (write_cache(fd, active_cache, active_nr) ||
375 close_lock_file(&index_lock))
376 die("unable to write new_index file");
377 commit_style = COMMIT_NORMAL;
378 return index_lock.filename;
379 }
381 /*
382 * As-is commit.
383 *
384 * (1) return the name of the real index file.
385 *
386 * The caller should run hooks on the real index,
387 * and create commit from the_index.
388 * We still need to refresh the index here.
389 */
390 if (!pathspec || !*pathspec) {
391 fd = hold_locked_index(&index_lock, 1);
392 refresh_cache_or_die(refresh_flags);
393 if (active_cache_changed) {
394 if (write_cache(fd, active_cache, active_nr) ||
395 commit_locked_index(&index_lock))
396 die("unable to write new_index file");
397 } else {
398 rollback_lock_file(&index_lock);
399 }
400 commit_style = COMMIT_AS_IS;
401 return get_index_file();
402 }
404 /*
405 * A partial commit.
406 *
407 * (0) find the set of affected paths;
408 * (1) get lock on the real index file;
409 * (2) update the_index with the given paths;
410 * (3) write the_index out to the real index (still locked);
411 * (4) get lock on the false index file;
412 * (5) reset the_index from HEAD;
413 * (6) update the_index the same way as (2);
414 * (7) write the_index out to the false index file;
415 * (8) return the name of the false index file (still locked);
416 *
417 * The caller should run hooks on the locked false index, and
418 * create commit from it. Then
419 * (A) if all goes well, commit the real index;
420 * (B) on failure, rollback the real index;
421 * In either case, rollback the false index.
422 */
423 commit_style = COMMIT_PARTIAL;
425 if (whence != FROM_COMMIT)
426 die("cannot do a partial commit during a %s.", whence_s());
428 memset(&partial, 0, sizeof(partial));
429 partial.strdup_strings = 1;
430 if (list_paths(&partial, initial_commit ? NULL : "HEAD", prefix, pathspec))
431 exit(1);
433 discard_cache();
434 if (read_cache() < 0)
435 die("cannot read the index");
437 fd = hold_locked_index(&index_lock, 1);
438 add_remove_files(&partial);
439 refresh_cache(REFRESH_QUIET);
440 if (write_cache(fd, active_cache, active_nr) ||
441 close_lock_file(&index_lock))
442 die("unable to write new_index file");
444 fd = hold_lock_file_for_update(&false_lock,
445 git_path("next-index-%"PRIuMAX,
446 (uintmax_t) getpid()),
447 LOCK_DIE_ON_ERROR);
449 create_base_index();
450 add_remove_files(&partial);
451 refresh_cache(REFRESH_QUIET);
453 if (write_cache(fd, active_cache, active_nr) ||
454 close_lock_file(&false_lock))
455 die("unable to write temporary index file");
457 discard_cache();
458 read_cache_from(false_lock.filename);
460 return false_lock.filename;
461 }
463 static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
464 struct wt_status *s)
465 {
466 unsigned char sha1[20];
468 if (s->relative_paths)
469 s->prefix = prefix;
471 if (amend) {
472 s->amend = 1;
473 s->reference = "HEAD^1";
474 }
475 s->verbose = verbose;
476 s->index_file = index_file;
477 s->fp = fp;
478 s->nowarn = nowarn;
479 s->is_initial = get_sha1(s->reference, sha1) ? 1 : 0;
481 wt_status_collect(s);
483 switch (status_format) {
484 case STATUS_FORMAT_SHORT:
485 wt_shortstatus_print(s, null_termination, status_show_branch);
486 break;
487 case STATUS_FORMAT_PORCELAIN:
488 wt_porcelain_print(s, null_termination);
489 break;
490 case STATUS_FORMAT_LONG:
491 wt_status_print(s);
492 break;
493 }
495 return s->commitable;
496 }
498 static int is_a_merge(const unsigned char *sha1)
499 {
500 struct commit *commit = lookup_commit(sha1);
501 if (!commit || parse_commit(commit))
502 die("could not parse HEAD commit");
503 return !!(commit->parents && commit->parents->next);
504 }
506 static const char sign_off_header[] = "Signed-off-by: ";
508 static void determine_author_info(struct strbuf *author_ident)
509 {
510 char *name, *email, *date;
512 name = getenv("GIT_AUTHOR_NAME");
513 email = getenv("GIT_AUTHOR_EMAIL");
514 date = getenv("GIT_AUTHOR_DATE");
516 if (author_message) {
517 const char *a, *lb, *rb, *eol;
519 a = strstr(author_message_buffer, "\nauthor ");
520 if (!a)
521 die("invalid commit: %s", author_message);
523 lb = strchrnul(a + strlen("\nauthor "), '<');
524 rb = strchrnul(lb, '>');
525 eol = strchrnul(rb, '\n');
526 if (!*lb || !*rb || !*eol)
527 die("invalid commit: %s", author_message);
529 if (lb == a + strlen("\nauthor "))
530 /* \nauthor <foo@example.com> */
531 name = xcalloc(1, 1);
532 else
533 name = xmemdupz(a + strlen("\nauthor "),
534 (lb - strlen(" ") -
535 (a + strlen("\nauthor "))));
536 email = xmemdupz(lb + strlen("<"), rb - (lb + strlen("<")));
537 date = xmemdupz(rb + strlen("> "), eol - (rb + strlen("> ")));
538 }
540 if (force_author) {
541 const char *lb = strstr(force_author, " <");
542 const char *rb = strchr(force_author, '>');
544 if (!lb || !rb)
545 die("malformed --author parameter");
546 name = xstrndup(force_author, lb - force_author);
547 email = xstrndup(lb + 2, rb - (lb + 2));
548 }
550 if (force_date)
551 date = force_date;
552 strbuf_addstr(author_ident, fmt_ident(name, email, date,
553 IDENT_ERROR_ON_NO_NAME));
554 }
556 static int ends_rfc2822_footer(struct strbuf *sb)
557 {
558 int ch;
559 int hit = 0;
560 int i, j, k;
561 int len = sb->len;
562 int first = 1;
563 const char *buf = sb->buf;
565 for (i = len - 1; i > 0; i--) {
566 if (hit && buf[i] == '\n')
567 break;
568 hit = (buf[i] == '\n');
569 }
571 while (i < len - 1 && buf[i] == '\n')
572 i++;
574 for (; i < len; i = k) {
575 for (k = i; k < len && buf[k] != '\n'; k++)
576 ; /* do nothing */
577 k++;
579 if ((buf[k] == ' ' || buf[k] == '\t') && !first)
580 continue;
582 first = 0;
584 for (j = 0; i + j < len; j++) {
585 ch = buf[i + j];
586 if (ch == ':')
587 break;
588 if (isalnum(ch) ||
589 (ch == '-'))
590 continue;
591 return 0;
592 }
593 }
594 return 1;
595 }
597 static char *cut_ident_timestamp_part(char *string)
598 {
599 char *ket = strrchr(string, '>');
600 if (!ket || ket[1] != ' ')
601 die("Malformed ident string: '%s'", string);
602 *++ket = '\0';
603 return ket;
604 }
606 static int prepare_to_commit(const char *index_file, const char *prefix,
607 struct wt_status *s,
608 struct strbuf *author_ident)
609 {
610 struct stat statbuf;
611 struct strbuf committer_ident = STRBUF_INIT;
612 int commitable, saved_color_setting;
613 struct strbuf sb = STRBUF_INIT;
614 char *buffer;
615 FILE *fp;
616 const char *hook_arg1 = NULL;
617 const char *hook_arg2 = NULL;
618 int ident_shown = 0;
620 if (!no_verify && run_hook(index_file, "pre-commit", NULL))
621 return 0;
623 if (squash_message) {
624 /*
625 * Insert the proper subject line before other commit
626 * message options add their content.
627 */
628 if (use_message && !strcmp(use_message, squash_message))
629 strbuf_addstr(&sb, "squash! ");
630 else {
631 struct pretty_print_context ctx = {0};
632 struct commit *c;
633 c = lookup_commit_reference_by_name(squash_message);
634 if (!c)
635 die("could not lookup commit %s", squash_message);
636 ctx.output_encoding = get_commit_output_encoding();
637 format_commit_message(c, "squash! %s\n\n", &sb,
638 &ctx);
639 }
640 }
642 if (message.len) {
643 strbuf_addbuf(&sb, &message);
644 hook_arg1 = "message";
645 } else if (logfile && !strcmp(logfile, "-")) {
646 if (isatty(0))
647 fprintf(stderr, "(reading log message from standard input)\n");
648 if (strbuf_read(&sb, 0, 0) < 0)
649 die_errno("could not read log from standard input");
650 hook_arg1 = "message";
651 } else if (logfile) {
652 if (strbuf_read_file(&sb, logfile, 0) < 0)
653 die_errno("could not read log file '%s'",
654 logfile);
655 hook_arg1 = "message";
656 } else if (use_message) {
657 buffer = strstr(use_message_buffer, "\n\n");
658 if (!buffer || buffer[2] == '\0')
659 die("commit has empty message");
660 strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
661 hook_arg1 = "commit";
662 hook_arg2 = use_message;
663 } else if (fixup_message) {
664 struct pretty_print_context ctx = {0};
665 struct commit *commit;
666 commit = lookup_commit_reference_by_name(fixup_message);
667 if (!commit)
668 die("could not lookup commit %s", fixup_message);
669 ctx.output_encoding = get_commit_output_encoding();
670 format_commit_message(commit, "fixup! %s\n\n",
671 &sb, &ctx);
672 hook_arg1 = "message";
673 } else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
674 if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
675 die_errno("could not read MERGE_MSG");
676 hook_arg1 = "merge";
677 } else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
678 if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
679 die_errno("could not read SQUASH_MSG");
680 hook_arg1 = "squash";
681 } else if (template_file) {
682 if (strbuf_read_file(&sb, template_file, 0) < 0)
683 die_errno("could not read '%s'", template_file);
684 hook_arg1 = "template";
685 }
687 /*
688 * The remaining cases don't modify the template message, but
689 * just set the argument(s) to the prepare-commit-msg hook.
690 */
691 else if (whence == FROM_MERGE)
692 hook_arg1 = "merge";
693 else if (whence == FROM_CHERRY_PICK) {
694 hook_arg1 = "commit";
695 hook_arg2 = "CHERRY_PICK_HEAD";
696 }
698 if (squash_message) {
699 /*
700 * If squash_commit was used for the commit subject,
701 * then we're possibly hijacking other commit log options.
702 * Reset the hook args to tell the real story.
703 */
704 hook_arg1 = "message";
705 hook_arg2 = "";
706 }
708 fp = fopen(git_path(commit_editmsg), "w");
709 if (fp == NULL)
710 die_errno("could not open '%s'", git_path(commit_editmsg));
712 if (cleanup_mode != CLEANUP_NONE)
713 stripspace(&sb, 0);
715 if (signoff) {
716 struct strbuf sob = STRBUF_INIT;
717 int i;
719 strbuf_addstr(&sob, sign_off_header);
720 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
721 getenv("GIT_COMMITTER_EMAIL")));
722 strbuf_addch(&sob, '\n');
723 for (i = sb.len - 1; i > 0 && sb.buf[i - 1] != '\n'; i--)
724 ; /* do nothing */
725 if (prefixcmp(sb.buf + i, sob.buf)) {
726 if (!i || !ends_rfc2822_footer(&sb))
727 strbuf_addch(&sb, '\n');
728 strbuf_addbuf(&sb, &sob);
729 }
730 strbuf_release(&sob);
731 }
733 if (fwrite(sb.buf, 1, sb.len, fp) < sb.len)
734 die_errno("could not write commit template");
736 strbuf_release(&sb);
738 /* This checks and barfs if author is badly specified */
739 determine_author_info(author_ident);
741 /* This checks if committer ident is explicitly given */
742 strbuf_addstr(&committer_ident, git_committer_info(0));
743 if (use_editor && include_status) {
744 char *ai_tmp, *ci_tmp;
745 if (whence != FROM_COMMIT)
746 fprintf(fp,
747 "#\n"
748 "# It looks like you may be committing a %s.\n"
749 "# If this is not correct, please remove the file\n"
750 "# %s\n"
751 "# and try again.\n"
752 "#\n",
753 whence_s(),
754 git_path(whence == FROM_MERGE
755 ? "MERGE_HEAD"
756 : "CHERRY_PICK_HEAD"));
757 fprintf(fp,
758 "\n"
759 "# Please enter the commit message for your changes.");
760 if (cleanup_mode == CLEANUP_ALL)
761 fprintf(fp,
762 " Lines starting\n"
763 "# with '#' will be ignored, and an empty"
764 " message aborts the commit.\n");
765 else /* CLEANUP_SPACE, that is. */
766 fprintf(fp,
767 " Lines starting\n"
768 "# with '#' will be kept; you may remove them"
769 " yourself if you want to.\n"
770 "# An empty message aborts the commit.\n");
771 if (only_include_assumed)
772 fprintf(fp, "# %s\n", only_include_assumed);
774 ai_tmp = cut_ident_timestamp_part(author_ident->buf);
775 ci_tmp = cut_ident_timestamp_part(committer_ident.buf);
776 if (strcmp(author_ident->buf, committer_ident.buf))
777 fprintf(fp,
778 "%s"
779 "# Author: %s\n",
780 ident_shown++ ? "" : "#\n",
781 author_ident->buf);
783 if (!user_ident_sufficiently_given())
784 fprintf(fp,
785 "%s"
786 "# Committer: %s\n",
787 ident_shown++ ? "" : "#\n",
788 committer_ident.buf);
790 if (ident_shown)
791 fprintf(fp, "#\n");
793 saved_color_setting = s->use_color;
794 s->use_color = 0;
795 commitable = run_status(fp, index_file, prefix, 1, s);
796 s->use_color = saved_color_setting;
798 *ai_tmp = ' ';
799 *ci_tmp = ' ';
800 } else {
801 unsigned char sha1[20];
802 const char *parent = "HEAD";
804 if (!active_nr && read_cache() < 0)
805 die("Cannot read index");
807 if (amend)
808 parent = "HEAD^1";
810 if (get_sha1(parent, sha1))
811 commitable = !!active_nr;
812 else
813 commitable = index_differs_from(parent, 0);
814 }
815 strbuf_release(&committer_ident);
817 fclose(fp);
819 /*
820 * Reject an attempt to record a non-merge empty commit without
821 * explicit --allow-empty. In the cherry-pick case, it may be
822 * empty due to conflict resolution, which the user should okay.
823 */
824 if (!commitable && whence != FROM_MERGE && !allow_empty &&
825 !(amend && is_a_merge(head_sha1))) {
826 run_status(stdout, index_file, prefix, 0, s);
827 if (amend)
828 fputs(empty_amend_advice, stderr);
829 else if (whence == FROM_CHERRY_PICK)
830 fputs(empty_cherry_pick_advice, stderr);
831 return 0;
832 }
834 /*
835 * Re-read the index as pre-commit hook could have updated it,
836 * and write it out as a tree. We must do this before we invoke
837 * the editor and after we invoke run_status above.
838 */
839 discard_cache();
840 read_cache_from(index_file);
841 if (!active_cache_tree)
842 active_cache_tree = cache_tree();
843 if (cache_tree_update(active_cache_tree,
844 active_cache, active_nr, 0, 0) < 0) {
845 error("Error building trees");
846 return 0;
847 }
849 if (run_hook(index_file, "prepare-commit-msg",
850 git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
851 return 0;
853 if (use_editor) {
854 char index[PATH_MAX];
855 const char *env[2] = { NULL };
856 env[0] = index;
857 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
858 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
859 fprintf(stderr,
860 "Please supply the message using either -m or -F option.\n");
861 exit(1);
862 }
863 }
865 if (!no_verify &&
866 run_hook(index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
867 return 0;
868 }
870 return 1;
871 }
873 /*
874 * Find out if the message in the strbuf contains only whitespace and
875 * Signed-off-by lines.
876 */
877 static int message_is_empty(struct strbuf *sb)
878 {
879 struct strbuf tmpl = STRBUF_INIT;
880 const char *nl;
881 int eol, i, start = 0;
883 if (cleanup_mode == CLEANUP_NONE && sb->len)
884 return 0;
886 /* See if the template is just a prefix of the message. */
887 if (template_file && strbuf_read_file(&tmpl, template_file, 0) > 0) {
888 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
889 if (start + tmpl.len <= sb->len &&
890 memcmp(tmpl.buf, sb->buf + start, tmpl.len) == 0)
891 start += tmpl.len;
892 }
893 strbuf_release(&tmpl);
895 /* Check if the rest is just whitespace and Signed-of-by's. */
896 for (i = start; i < sb->len; i++) {
897 nl = memchr(sb->buf + i, '\n', sb->len - i);
898 if (nl)
899 eol = nl - sb->buf;
900 else
901 eol = sb->len;
903 if (strlen(sign_off_header) <= eol - i &&
904 !prefixcmp(sb->buf + i, sign_off_header)) {
905 i = eol;
906 continue;
907 }
908 while (i < eol)
909 if (!isspace(sb->buf[i++]))
910 return 0;
911 }
913 return 1;
914 }
916 static const char *find_author_by_nickname(const char *name)
917 {
918 struct rev_info revs;
919 struct commit *commit;
920 struct strbuf buf = STRBUF_INIT;
921 const char *av[20];
922 int ac = 0;
924 init_revisions(&revs, NULL);
925 strbuf_addf(&buf, "--author=%s", name);
926 av[++ac] = "--all";
927 av[++ac] = "-i";
928 av[++ac] = buf.buf;
929 av[++ac] = NULL;
930 setup_revisions(ac, av, &revs, NULL);
931 prepare_revision_walk(&revs);
932 commit = get_revision(&revs);
933 if (commit) {
934 struct pretty_print_context ctx = {0};
935 ctx.date_mode = DATE_NORMAL;
936 strbuf_release(&buf);
937 format_commit_message(commit, "%an <%ae>", &buf, &ctx);
938 return strbuf_detach(&buf, NULL);
939 }
940 die("No existing author found with '%s'", name);
941 }
944 static void handle_untracked_files_arg(struct wt_status *s)
945 {
946 if (!untracked_files_arg)
947 ; /* default already initialized */
948 else if (!strcmp(untracked_files_arg, "no"))
949 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
950 else if (!strcmp(untracked_files_arg, "normal"))
951 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
952 else if (!strcmp(untracked_files_arg, "all"))
953 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
954 else
955 die("Invalid untracked files mode '%s'", untracked_files_arg);
956 }
958 static const char *read_commit_message(const char *name)
959 {
960 const char *out_enc, *out;
961 struct commit *commit;
963 commit = lookup_commit_reference_by_name(name);
964 if (!commit)
965 die("could not lookup commit %s", name);
966 out_enc = get_commit_output_encoding();
967 out = logmsg_reencode(commit, out_enc);
969 /*
970 * If we failed to reencode the buffer, just copy it
971 * byte for byte so the user can try to fix it up.
972 * This also handles the case where input and output
973 * encodings are identical.
974 */
975 if (out == NULL)
976 out = xstrdup(commit->buffer);
977 return out;
978 }
980 static int parse_and_validate_options(int argc, const char *argv[],
981 const char * const usage[],
982 const char *prefix,
983 struct wt_status *s)
984 {
985 int f = 0;
987 argc = parse_options(argc, argv, prefix, builtin_commit_options, usage,
988 0);
990 if (force_author && !strchr(force_author, '>'))
991 force_author = find_author_by_nickname(force_author);
993 if (force_author && renew_authorship)
994 die("Using both --reset-author and --author does not make sense");
996 if (logfile || message.len || use_message || fixup_message)
997 use_editor = 0;
998 if (edit_flag)
999 use_editor = 1;
1000 if (!use_editor)
1001 setenv("GIT_EDITOR", ":", 1);
1003 if (get_sha1("HEAD", head_sha1))
1004 initial_commit = 1;
1006 /* Sanity check options */
1007 if (amend && initial_commit)
1008 die("You have nothing to amend.");
1009 if (amend && whence != FROM_COMMIT)
1010 die("You are in the middle of a %s -- cannot amend.", whence_s());
1011 if (fixup_message && squash_message)
1012 die("Options --squash and --fixup cannot be used together");
1013 if (use_message)
1014 f++;
1015 if (edit_message)
1016 f++;
1017 if (fixup_message)
1018 f++;
1019 if (logfile)
1020 f++;
1021 if (f > 1)
1022 die("Only one of -c/-C/-F/--fixup can be used.");
1023 if (message.len && f > 0)
1024 die("Option -m cannot be combined with -c/-C/-F/--fixup.");
1025 if (edit_message)
1026 use_message = edit_message;
1027 if (amend && !use_message && !fixup_message)
1028 use_message = "HEAD";
1029 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
1030 die("--reset-author can be used only with -C, -c or --amend.");
1031 if (use_message) {
1032 use_message_buffer = read_commit_message(use_message);
1033 if (!renew_authorship) {
1034 author_message = use_message;
1035 author_message_buffer = use_message_buffer;
1036 }
1037 }
1038 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1039 author_message = "CHERRY_PICK_HEAD";
1040 author_message_buffer = read_commit_message(author_message);
1041 }
1043 if (!!also + !!only + !!all + !!interactive > 1)
1044 die("Only one of --include/--only/--all/--interactive can be used.");
1045 if (argc == 0 && (also || (only && !amend)))
1046 die("No paths with --include/--only does not make sense.");
1047 if (argc == 0 && only && amend)
1048 only_include_assumed = "Clever... amending the last one with dirty index.";
1049 if (argc > 0 && !also && !only)
1050 only_include_assumed = "Explicit paths specified without -i nor -o; assuming --only paths...";
1051 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1052 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1053 else if (!strcmp(cleanup_arg, "verbatim"))
1054 cleanup_mode = CLEANUP_NONE;
1055 else if (!strcmp(cleanup_arg, "whitespace"))
1056 cleanup_mode = CLEANUP_SPACE;
1057 else if (!strcmp(cleanup_arg, "strip"))
1058 cleanup_mode = CLEANUP_ALL;
1059 else
1060 die("Invalid cleanup mode %s", cleanup_arg);
1062 handle_untracked_files_arg(s);
1064 if (all && argc > 0)
1065 die("Paths with -a does not make sense.");
1066 else if (interactive && argc > 0)
1067 die("Paths with --interactive does not make sense.");
1069 if (null_termination && status_format == STATUS_FORMAT_LONG)
1070 status_format = STATUS_FORMAT_PORCELAIN;
1071 if (status_format != STATUS_FORMAT_LONG)
1072 dry_run = 1;
1074 return argc;
1075 }
1077 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1078 struct wt_status *s)
1079 {
1080 int commitable;
1081 const char *index_file;
1083 index_file = prepare_index(argc, argv, prefix, 1);
1084 commitable = run_status(stdout, index_file, prefix, 0, s);
1085 rollback_index_files();
1087 return commitable ? 0 : 1;
1088 }
1090 static int parse_status_slot(const char *var, int offset)
1091 {
1092 if (!strcasecmp(var+offset, "header"))
1093 return WT_STATUS_HEADER;
1094 if (!strcasecmp(var+offset, "branch"))
1095 return WT_STATUS_ONBRANCH;
1096 if (!strcasecmp(var+offset, "updated")
1097 || !strcasecmp(var+offset, "added"))
1098 return WT_STATUS_UPDATED;
1099 if (!strcasecmp(var+offset, "changed"))
1100 return WT_STATUS_CHANGED;
1101 if (!strcasecmp(var+offset, "untracked"))
1102 return WT_STATUS_UNTRACKED;
1103 if (!strcasecmp(var+offset, "nobranch"))
1104 return WT_STATUS_NOBRANCH;
1105 if (!strcasecmp(var+offset, "unmerged"))
1106 return WT_STATUS_UNMERGED;
1107 return -1;
1108 }
1110 static int git_status_config(const char *k, const char *v, void *cb)
1111 {
1112 struct wt_status *s = cb;
1114 if (!strcmp(k, "status.submodulesummary")) {
1115 int is_bool;
1116 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1117 if (is_bool && s->submodule_summary)
1118 s->submodule_summary = -1;
1119 return 0;
1120 }
1121 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1122 s->use_color = git_config_colorbool(k, v, -1);
1123 return 0;
1124 }
1125 if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
1126 int slot = parse_status_slot(k, 13);
1127 if (slot < 0)
1128 return 0;
1129 if (!v)
1130 return config_error_nonbool(k);
1131 color_parse(v, k, s->color_palette[slot]);
1132 return 0;
1133 }
1134 if (!strcmp(k, "status.relativepaths")) {
1135 s->relative_paths = git_config_bool(k, v);
1136 return 0;
1137 }
1138 if (!strcmp(k, "status.showuntrackedfiles")) {
1139 if (!v)
1140 return config_error_nonbool(k);
1141 else if (!strcmp(v, "no"))
1142 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1143 else if (!strcmp(v, "normal"))
1144 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1145 else if (!strcmp(v, "all"))
1146 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1147 else
1148 return error("Invalid untracked files mode '%s'", v);
1149 return 0;
1150 }
1151 return git_diff_ui_config(k, v, NULL);
1152 }
1154 int cmd_status(int argc, const char **argv, const char *prefix)
1155 {
1156 struct wt_status s;
1157 int fd;
1158 unsigned char sha1[20];
1159 static struct option builtin_status_options[] = {
1160 OPT__VERBOSE(&verbose, "be verbose"),
1161 OPT_SET_INT('s', "short", &status_format,
1162 "show status concisely", STATUS_FORMAT_SHORT),
1163 OPT_BOOLEAN('b', "branch", &status_show_branch,
1164 "show branch information"),
1165 OPT_SET_INT(0, "porcelain", &status_format,
1166 "machine-readable output",
1167 STATUS_FORMAT_PORCELAIN),
1168 OPT_BOOLEAN('z', "null", &null_termination,
1169 "terminate entries with NUL"),
1170 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1171 "mode",
1172 "show untracked files, optional modes: all, normal, no. (Default: all)",
1173 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1174 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status,
1175 "show ignored files"),
1176 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, "when",
1177 "ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)",
1178 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1179 OPT_END(),
1180 };
1182 if (argc == 2 && !strcmp(argv[1], "-h"))
1183 usage_with_options(builtin_status_usage, builtin_status_options);
1185 if (null_termination && status_format == STATUS_FORMAT_LONG)
1186 status_format = STATUS_FORMAT_PORCELAIN;
1188 wt_status_prepare(&s);
1189 gitmodules_config();
1190 git_config(git_status_config, &s);
1191 determine_whence(&s);
1192 argc = parse_options(argc, argv, prefix,
1193 builtin_status_options,
1194 builtin_status_usage, 0);
1195 handle_untracked_files_arg(&s);
1196 if (show_ignored_in_status)
1197 s.show_ignored_files = 1;
1198 if (*argv)
1199 s.pathspec = get_pathspec(prefix, argv);
1201 read_cache_preload(s.pathspec);
1202 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);
1204 fd = hold_locked_index(&index_lock, 0);
1205 if (0 <= fd) {
1206 if (active_cache_changed &&
1207 !write_cache(fd, active_cache, active_nr))
1208 commit_locked_index(&index_lock);
1209 else
1210 rollback_lock_file(&index_lock);
1211 }
1213 s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1214 s.ignore_submodule_arg = ignore_submodule_arg;
1215 wt_status_collect(&s);
1217 if (s.relative_paths)
1218 s.prefix = prefix;
1219 if (s.use_color == -1)
1220 s.use_color = git_use_color_default;
1221 if (diff_use_color_default == -1)
1222 diff_use_color_default = git_use_color_default;
1224 switch (status_format) {
1225 case STATUS_FORMAT_SHORT:
1226 wt_shortstatus_print(&s, null_termination, status_show_branch);
1227 break;
1228 case STATUS_FORMAT_PORCELAIN:
1229 wt_porcelain_print(&s, null_termination);
1230 break;
1231 case STATUS_FORMAT_LONG:
1232 s.verbose = verbose;
1233 s.ignore_submodule_arg = ignore_submodule_arg;
1234 wt_status_print(&s);
1235 break;
1236 }
1237 return 0;
1238 }
1240 static void print_summary(const char *prefix, const unsigned char *sha1)
1241 {
1242 struct rev_info rev;
1243 struct commit *commit;
1244 struct strbuf format = STRBUF_INIT;
1245 unsigned char junk_sha1[20];
1246 const char *head = resolve_ref("HEAD", junk_sha1, 0, NULL);
1247 struct pretty_print_context pctx = {0};
1248 struct strbuf author_ident = STRBUF_INIT;
1249 struct strbuf committer_ident = STRBUF_INIT;
1251 commit = lookup_commit(sha1);
1252 if (!commit)
1253 die("couldn't look up newly created commit");
1254 if (!commit || parse_commit(commit))
1255 die("could not parse newly created commit");
1257 strbuf_addstr(&format, "format:%h] %s");
1259 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1260 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1261 if (strbuf_cmp(&author_ident, &committer_ident)) {
1262 strbuf_addstr(&format, "\n Author: ");
1263 strbuf_addbuf_percentquote(&format, &author_ident);
1264 }
1265 if (!user_ident_sufficiently_given()) {
1266 strbuf_addstr(&format, "\n Committer: ");
1267 strbuf_addbuf_percentquote(&format, &committer_ident);
1268 if (advice_implicit_identity) {
1269 strbuf_addch(&format, '\n');
1270 strbuf_addstr(&format, implicit_ident_advice);
1271 }
1272 }
1273 strbuf_release(&author_ident);
1274 strbuf_release(&committer_ident);
1276 init_revisions(&rev, prefix);
1277 setup_revisions(0, NULL, &rev, NULL);
1279 rev.diff = 1;
1280 rev.diffopt.output_format =
1281 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1283 rev.verbose_header = 1;
1284 rev.show_root_diff = 1;
1285 get_commit_format(format.buf, &rev);
1286 rev.always_show_header = 0;
1287 rev.diffopt.detect_rename = 1;
1288 rev.diffopt.rename_limit = 100;
1289 rev.diffopt.break_opt = 0;
1290 diff_setup_done(&rev.diffopt);
1292 printf("[%s%s ",
1293 !prefixcmp(head, "refs/heads/") ?
1294 head + 11 :
1295 !strcmp(head, "HEAD") ?
1296 "detached HEAD" :
1297 head,
1298 initial_commit ? " (root-commit)" : "");
1300 if (!log_tree_commit(&rev, commit)) {
1301 rev.always_show_header = 1;
1302 rev.use_terminator = 1;
1303 log_tree_commit(&rev, commit);
1304 }
1306 strbuf_release(&format);
1307 }
1309 static int git_commit_config(const char *k, const char *v, void *cb)
1310 {
1311 struct wt_status *s = cb;
1313 if (!strcmp(k, "commit.template"))
1314 return git_config_pathname(&template_file, k, v);
1315 if (!strcmp(k, "commit.status")) {
1316 include_status = git_config_bool(k, v);
1317 return 0;
1318 }
1320 return git_status_config(k, v, s);
1321 }
1323 static const char post_rewrite_hook[] = "hooks/post-rewrite";
1325 static int run_rewrite_hook(const unsigned char *oldsha1,
1326 const unsigned char *newsha1)
1327 {
1328 /* oldsha1 SP newsha1 LF NUL */
1329 static char buf[2*40 + 3];
1330 struct child_process proc;
1331 const char *argv[3];
1332 int code;
1333 size_t n;
1335 if (access(git_path(post_rewrite_hook), X_OK) < 0)
1336 return 0;
1338 argv[0] = git_path(post_rewrite_hook);
1339 argv[1] = "amend";
1340 argv[2] = NULL;
1342 memset(&proc, 0, sizeof(proc));
1343 proc.argv = argv;
1344 proc.in = -1;
1345 proc.stdout_to_stderr = 1;
1347 code = start_command(&proc);
1348 if (code)
1349 return code;
1350 n = snprintf(buf, sizeof(buf), "%s %s\n",
1351 sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1352 write_in_full(proc.in, buf, n);
1353 close(proc.in);
1354 return finish_command(&proc);
1355 }
1357 int cmd_commit(int argc, const char **argv, const char *prefix)
1358 {
1359 struct strbuf sb = STRBUF_INIT;
1360 struct strbuf author_ident = STRBUF_INIT;
1361 const char *index_file, *reflog_msg;
1362 char *nl, *p;
1363 unsigned char commit_sha1[20];
1364 struct ref_lock *ref_lock;
1365 struct commit_list *parents = NULL, **pptr = &parents;
1366 struct stat statbuf;
1367 int allow_fast_forward = 1;
1368 struct wt_status s;
1370 if (argc == 2 && !strcmp(argv[1], "-h"))
1371 usage_with_options(builtin_commit_usage, builtin_commit_options);
1373 wt_status_prepare(&s);
1374 git_config(git_commit_config, &s);
1375 determine_whence(&s);
1377 if (s.use_color == -1)
1378 s.use_color = git_use_color_default;
1379 argc = parse_and_validate_options(argc, argv, builtin_commit_usage,
1380 prefix, &s);
1381 if (dry_run) {
1382 if (diff_use_color_default == -1)
1383 diff_use_color_default = git_use_color_default;
1384 return dry_run_commit(argc, argv, prefix, &s);
1385 }
1386 index_file = prepare_index(argc, argv, prefix, 0);
1388 /* Set up everything for writing the commit object. This includes
1389 running hooks, writing the trees, and interacting with the user. */
1390 if (!prepare_to_commit(index_file, prefix, &s, &author_ident)) {
1391 rollback_index_files();
1392 return 1;
1393 }
1395 /* Determine parents */
1396 reflog_msg = getenv("GIT_REFLOG_ACTION");
1397 if (initial_commit) {
1398 if (!reflog_msg)
1399 reflog_msg = "commit (initial)";
1400 } else if (amend) {
1401 struct commit_list *c;
1402 struct commit *commit;
1404 if (!reflog_msg)
1405 reflog_msg = "commit (amend)";
1406 commit = lookup_commit(head_sha1);
1407 if (!commit || parse_commit(commit))
1408 die("could not parse HEAD commit");
1410 for (c = commit->parents; c; c = c->next)
1411 pptr = &commit_list_insert(c->item, pptr)->next;
1412 } else if (whence == FROM_MERGE) {
1413 struct strbuf m = STRBUF_INIT;
1414 FILE *fp;
1416 if (!reflog_msg)
1417 reflog_msg = "commit (merge)";
1418 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1419 fp = fopen(git_path("MERGE_HEAD"), "r");
1420 if (fp == NULL)
1421 die_errno("could not open '%s' for reading",
1422 git_path("MERGE_HEAD"));
1423 while (strbuf_getline(&m, fp, '\n') != EOF) {
1424 unsigned char sha1[20];
1425 if (get_sha1_hex(m.buf, sha1) < 0)
1426 die("Corrupt MERGE_HEAD file (%s)", m.buf);
1427 pptr = &commit_list_insert(lookup_commit(sha1), pptr)->next;
1428 }
1429 fclose(fp);
1430 strbuf_release(&m);
1431 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1432 if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1433 die_errno("could not read MERGE_MODE");
1434 if (!strcmp(sb.buf, "no-ff"))
1435 allow_fast_forward = 0;
1436 }
1437 if (allow_fast_forward)
1438 parents = reduce_heads(parents);
1439 } else {
1440 if (!reflog_msg)
1441 reflog_msg = (whence == FROM_CHERRY_PICK)
1442 ? "commit (cherry-pick)"
1443 : "commit";
1444 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1445 }
1447 /* Finally, get the commit message */
1448 strbuf_reset(&sb);
1449 if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1450 int saved_errno = errno;
1451 rollback_index_files();
1452 die("could not read commit message: %s", strerror(saved_errno));
1453 }
1455 /* Truncate the message just before the diff, if any. */
1456 if (verbose) {
1457 p = strstr(sb.buf, "\ndiff --git ");
1458 if (p != NULL)
1459 strbuf_setlen(&sb, p - sb.buf + 1);
1460 }
1462 if (cleanup_mode != CLEANUP_NONE)
1463 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1464 if (message_is_empty(&sb) && !allow_empty_message) {
1465 rollback_index_files();
1466 fprintf(stderr, "Aborting commit due to empty commit message.\n");
1467 exit(1);
1468 }
1470 if (commit_tree(sb.buf, active_cache_tree->sha1, parents, commit_sha1,
1471 author_ident.buf)) {
1472 rollback_index_files();
1473 die("failed to write commit object");
1474 }
1475 strbuf_release(&author_ident);
1477 ref_lock = lock_any_ref_for_update("HEAD",
1478 initial_commit ? NULL : head_sha1,
1479 0);
1481 nl = strchr(sb.buf, '\n');
1482 if (nl)
1483 strbuf_setlen(&sb, nl + 1 - sb.buf);
1484 else
1485 strbuf_addch(&sb, '\n');
1486 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1487 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1489 if (!ref_lock) {
1490 rollback_index_files();
1491 die("cannot lock HEAD ref");
1492 }
1493 if (write_ref_sha1(ref_lock, commit_sha1, sb.buf) < 0) {
1494 rollback_index_files();
1495 die("cannot update HEAD ref");
1496 }
1498 unlink(git_path("CHERRY_PICK_HEAD"));
1499 unlink(git_path("MERGE_HEAD"));
1500 unlink(git_path("MERGE_MSG"));
1501 unlink(git_path("MERGE_MODE"));
1502 unlink(git_path("SQUASH_MSG"));
1504 if (commit_index_files())
1505 die ("Repository has been updated, but unable to write\n"
1506 "new_index file. Check that disk is not full or quota is\n"
1507 "not exceeded, and then \"git reset HEAD\" to recover.");
1509 rerere(0);
1510 run_hook(get_index_file(), "post-commit", NULL);
1511 if (amend && !no_post_rewrite) {
1512 struct notes_rewrite_cfg *cfg;
1513 cfg = init_copy_notes_for_rewrite("amend");
1514 if (cfg) {
1515 copy_note_for_rewrite(cfg, head_sha1, commit_sha1);
1516 finish_copy_notes_for_rewrite(cfg);
1517 }
1518 run_rewrite_hook(head_sha1, commit_sha1);
1519 }
1520 if (!quiet)
1521 print_summary(prefix, commit_sha1);
1523 return 0;
1524 }