Merge branch 'tr/cache-tree'
[git/jrn.git] / builtin / commit.c
blob039c04fe9dbbeb4bea15a383f55c23c8c4e60f78
1 /*
2 * Builtin "git commit"
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
35 static const char * const builtin_status_usage[] = {
36 "git status [options] [--] <filepattern>...",
37 NULL
40 static const char implicit_ident_advice[] =
41 N_("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 N_("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 N_("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 const char *use_message_buffer;
66 static const char commit_editmsg[] = "COMMIT_EDITMSG";
67 static struct lock_file index_lock; /* real index */
68 static struct lock_file false_lock; /* used only for partial commits */
69 static enum {
70 COMMIT_AS_IS = 1,
71 COMMIT_NORMAL,
72 COMMIT_PARTIAL
73 } commit_style;
75 static const char *logfile, *force_author;
76 static const char *template_file;
78 * The _message variables are commit names from which to take
79 * the commit message and/or authorship.
81 static const char *author_message, *author_message_buffer;
82 static char *edit_message, *use_message;
83 static char *fixup_message, *squash_message;
84 static int all, also, interactive, patch_interactive, only, amend, signoff;
85 static int edit_flag = -1; /* unspecified */
86 static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
87 static int no_post_rewrite, allow_empty_message;
88 static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
90 * The default commit message cleanup mode will remove the lines
91 * beginning with # (shell comments) and leading and trailing
92 * whitespaces (empty lines or containing only whitespaces)
93 * if editor is used, and only the whitespaces if the message
94 * is specified explicitly.
96 static enum {
97 CLEANUP_SPACE,
98 CLEANUP_NONE,
99 CLEANUP_ALL
100 } cleanup_mode;
101 static char *cleanup_arg;
103 static enum commit_whence whence;
104 static int use_editor = 1, include_status = 1;
105 static int show_ignored_in_status;
106 static const char *only_include_assumed;
107 static struct strbuf message;
109 static int null_termination;
110 static enum {
111 STATUS_FORMAT_LONG,
112 STATUS_FORMAT_SHORT,
113 STATUS_FORMAT_PORCELAIN
114 } status_format = STATUS_FORMAT_LONG;
115 static int status_show_branch;
117 static int opt_parse_m(const struct option *opt, const char *arg, int unset)
119 struct strbuf *buf = opt->value;
120 if (unset)
121 strbuf_setlen(buf, 0);
122 else {
123 strbuf_addstr(buf, arg);
124 strbuf_addstr(buf, "\n\n");
126 return 0;
129 static struct option builtin_commit_options[] = {
130 OPT__QUIET(&quiet, "suppress summary after successful commit"),
131 OPT__VERBOSE(&verbose, "show diff in commit message template"),
133 OPT_GROUP("Commit message options"),
134 OPT_FILENAME('F', "file", &logfile, "read message from file"),
135 OPT_STRING(0, "author", &force_author, "author", "override author for commit"),
136 OPT_STRING(0, "date", &force_date, "date", "override date for commit"),
137 OPT_CALLBACK('m', "message", &message, "message", "commit message", opt_parse_m),
138 OPT_STRING('c', "reedit-message", &edit_message, "commit", "reuse and edit message from specified commit"),
139 OPT_STRING('C', "reuse-message", &use_message, "commit", "reuse message from specified commit"),
140 OPT_STRING(0, "fixup", &fixup_message, "commit", "use autosquash formatted message to fixup specified commit"),
141 OPT_STRING(0, "squash", &squash_message, "commit", "use autosquash formatted message to squash specified commit"),
142 OPT_BOOLEAN(0, "reset-author", &renew_authorship, "the commit is authored by me now (used with -C-c/--amend)"),
143 OPT_BOOLEAN('s', "signoff", &signoff, "add Signed-off-by:"),
144 OPT_FILENAME('t', "template", &template_file, "use specified template file"),
145 OPT_BOOL('e', "edit", &edit_flag, "force edit of commit"),
146 OPT_STRING(0, "cleanup", &cleanup_arg, "default", "how to strip spaces and #comments from message"),
147 OPT_BOOLEAN(0, "status", &include_status, "include status in commit message template"),
148 /* end commit message options */
150 OPT_GROUP("Commit contents options"),
151 OPT_BOOLEAN('a', "all", &all, "commit all changed files"),
152 OPT_BOOLEAN('i', "include", &also, "add specified files to index for commit"),
153 OPT_BOOLEAN(0, "interactive", &interactive, "interactively add files"),
154 OPT_BOOLEAN('p', "patch", &patch_interactive, "interactively add changes"),
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()
180 static void determine_whence(struct wt_status *s)
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;
192 static const char *whence_s(void)
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;
207 return s;
210 static void rollback_index_files(void)
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;
225 static int commit_index_files(void)
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;
241 return err;
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.
248 static int list_paths(struct string_list *list, const char *with_tree,
249 const char *prefix, const char **pattern)
251 int i;
252 char *m;
254 for (i = 0; pattern[i]; i++)
256 m = xcalloc(1, i);
258 if (with_tree) {
259 char *max_prefix = common_prefix(pattern);
260 overlay_tree_on_cache(with_tree, max_prefix ? max_prefix : prefix);
261 free(max_prefix);
264 for (i = 0; i < active_nr; i++) {
265 struct cache_entry *ce = active_cache[i];
266 struct string_list_item *item;
268 if (ce->ce_flags & CE_UPDATE)
269 continue;
270 if (!match_pathspec(pattern, ce->name, ce_namelen(ce), 0, m))
271 continue;
272 item = string_list_insert(list, ce->name);
273 if (ce_skip_worktree(ce))
274 item->util = item; /* better a valid pointer than a fake one */
277 return report_path_error(m, pattern, prefix);
280 static void add_remove_files(struct string_list *list)
282 int i;
283 for (i = 0; i < list->nr; i++) {
284 struct stat st;
285 struct string_list_item *p = &(list->items[i]);
287 /* p->util is skip-worktree */
288 if (p->util)
289 continue;
291 if (!lstat(p->string, &st)) {
292 if (add_to_cache(p->string, &st, 0))
293 die(_("updating files failed"));
294 } else
295 remove_file_from_cache(p->string);
299 static void create_base_index(const struct commit *current_head)
301 struct tree *tree;
302 struct unpack_trees_options opts;
303 struct tree_desc t;
305 if (!current_head) {
306 discard_cache();
307 return;
310 memset(&opts, 0, sizeof(opts));
311 opts.head_idx = 1;
312 opts.index_only = 1;
313 opts.merge = 1;
314 opts.src_index = &the_index;
315 opts.dst_index = &the_index;
317 opts.fn = oneway_merge;
318 tree = parse_tree_indirect(current_head->object.sha1);
319 if (!tree)
320 die(_("failed to unpack HEAD tree object"));
321 parse_tree(tree);
322 init_tree_desc(&t, tree->buffer, tree->size);
323 if (unpack_trees(1, &t, &opts))
324 exit(128); /* We've already reported the error, finish dying */
327 static void refresh_cache_or_die(int refresh_flags)
330 * refresh_flags contains REFRESH_QUIET, so the only errors
331 * are for unmerged entries.
333 if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
334 die_resolve_conflict("commit");
337 static char *prepare_index(int argc, const char **argv, const char *prefix,
338 const struct commit *current_head, int is_status)
340 int fd;
341 struct string_list partial;
342 const char **pathspec = NULL;
343 char *old_index_env = NULL;
344 int refresh_flags = REFRESH_QUIET;
346 if (is_status)
347 refresh_flags |= REFRESH_UNMERGED;
349 if (*argv)
350 pathspec = get_pathspec(prefix, argv);
352 if (read_cache_preload(pathspec) < 0)
353 die(_("index file corrupt"));
355 if (interactive) {
356 fd = hold_locked_index(&index_lock, 1);
358 refresh_cache_or_die(refresh_flags);
360 if (write_cache(fd, active_cache, active_nr) ||
361 close_lock_file(&index_lock))
362 die(_("unable to create temporary index"));
364 old_index_env = getenv(INDEX_ENVIRONMENT);
365 setenv(INDEX_ENVIRONMENT, index_lock.filename, 1);
367 if (interactive_add(argc, argv, prefix, patch_interactive) != 0)
368 die(_("interactive add failed"));
370 if (old_index_env && *old_index_env)
371 setenv(INDEX_ENVIRONMENT, old_index_env, 1);
372 else
373 unsetenv(INDEX_ENVIRONMENT);
375 discard_cache();
376 read_cache_from(index_lock.filename);
378 commit_style = COMMIT_NORMAL;
379 return index_lock.filename;
383 * Non partial, non as-is commit.
385 * (1) get the real index;
386 * (2) update the_index as necessary;
387 * (3) write the_index out to the real index (still locked);
388 * (4) return the name of the locked index file.
390 * The caller should run hooks on the locked real index, and
391 * (A) if all goes well, commit the real index;
392 * (B) on failure, rollback the real index.
394 if (all || (also && pathspec && *pathspec)) {
395 fd = hold_locked_index(&index_lock, 1);
396 add_files_to_cache(also ? prefix : NULL, pathspec, 0);
397 refresh_cache_or_die(refresh_flags);
398 update_main_cache_tree(1);
399 if (write_cache(fd, active_cache, active_nr) ||
400 close_lock_file(&index_lock))
401 die(_("unable to write new_index file"));
402 commit_style = COMMIT_NORMAL;
403 return index_lock.filename;
407 * As-is commit.
409 * (1) return the name of the real index file.
411 * The caller should run hooks on the real index,
412 * and create commit from the_index.
413 * We still need to refresh the index here.
415 if (!pathspec || !*pathspec) {
416 fd = hold_locked_index(&index_lock, 1);
417 refresh_cache_or_die(refresh_flags);
418 if (active_cache_changed) {
419 update_main_cache_tree(1);
420 if (write_cache(fd, active_cache, active_nr) ||
421 commit_locked_index(&index_lock))
422 die(_("unable to write new_index file"));
423 } else {
424 rollback_lock_file(&index_lock);
426 commit_style = COMMIT_AS_IS;
427 return get_index_file();
431 * A partial commit.
433 * (0) find the set of affected paths;
434 * (1) get lock on the real index file;
435 * (2) update the_index with the given paths;
436 * (3) write the_index out to the real index (still locked);
437 * (4) get lock on the false index file;
438 * (5) reset the_index from HEAD;
439 * (6) update the_index the same way as (2);
440 * (7) write the_index out to the false index file;
441 * (8) return the name of the false index file (still locked);
443 * The caller should run hooks on the locked false index, and
444 * create commit from it. Then
445 * (A) if all goes well, commit the real index;
446 * (B) on failure, rollback the real index;
447 * In either case, rollback the false index.
449 commit_style = COMMIT_PARTIAL;
451 if (whence != FROM_COMMIT)
452 die(_("cannot do a partial commit during a %s."), whence_s());
454 memset(&partial, 0, sizeof(partial));
455 partial.strdup_strings = 1;
456 if (list_paths(&partial, !current_head ? NULL : "HEAD", prefix, pathspec))
457 exit(1);
459 discard_cache();
460 if (read_cache() < 0)
461 die(_("cannot read the index"));
463 fd = hold_locked_index(&index_lock, 1);
464 add_remove_files(&partial);
465 refresh_cache(REFRESH_QUIET);
466 if (write_cache(fd, active_cache, active_nr) ||
467 close_lock_file(&index_lock))
468 die(_("unable to write new_index file"));
470 fd = hold_lock_file_for_update(&false_lock,
471 git_path("next-index-%"PRIuMAX,
472 (uintmax_t) getpid()),
473 LOCK_DIE_ON_ERROR);
475 create_base_index(current_head);
476 add_remove_files(&partial);
477 refresh_cache(REFRESH_QUIET);
479 if (write_cache(fd, active_cache, active_nr) ||
480 close_lock_file(&false_lock))
481 die(_("unable to write temporary index file"));
483 discard_cache();
484 read_cache_from(false_lock.filename);
486 return false_lock.filename;
489 static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
490 struct wt_status *s)
492 unsigned char sha1[20];
494 if (s->relative_paths)
495 s->prefix = prefix;
497 if (amend) {
498 s->amend = 1;
499 s->reference = "HEAD^1";
501 s->verbose = verbose;
502 s->index_file = index_file;
503 s->fp = fp;
504 s->nowarn = nowarn;
505 s->is_initial = get_sha1(s->reference, sha1) ? 1 : 0;
507 wt_status_collect(s);
509 switch (status_format) {
510 case STATUS_FORMAT_SHORT:
511 wt_shortstatus_print(s, null_termination, status_show_branch);
512 break;
513 case STATUS_FORMAT_PORCELAIN:
514 wt_porcelain_print(s, null_termination);
515 break;
516 case STATUS_FORMAT_LONG:
517 wt_status_print(s);
518 break;
521 return s->commitable;
524 static int is_a_merge(const struct commit *current_head)
526 return !!(current_head->parents && current_head->parents->next);
529 static const char sign_off_header[] = "Signed-off-by: ";
531 static void determine_author_info(struct strbuf *author_ident)
533 char *name, *email, *date;
535 name = getenv("GIT_AUTHOR_NAME");
536 email = getenv("GIT_AUTHOR_EMAIL");
537 date = getenv("GIT_AUTHOR_DATE");
539 if (author_message) {
540 const char *a, *lb, *rb, *eol;
542 a = strstr(author_message_buffer, "\nauthor ");
543 if (!a)
544 die(_("invalid commit: %s"), author_message);
546 lb = strchrnul(a + strlen("\nauthor "), '<');
547 rb = strchrnul(lb, '>');
548 eol = strchrnul(rb, '\n');
549 if (!*lb || !*rb || !*eol)
550 die(_("invalid commit: %s"), author_message);
552 if (lb == a + strlen("\nauthor "))
553 /* \nauthor <foo@example.com> */
554 name = xcalloc(1, 1);
555 else
556 name = xmemdupz(a + strlen("\nauthor "),
557 (lb - strlen(" ") -
558 (a + strlen("\nauthor "))));
559 email = xmemdupz(lb + strlen("<"), rb - (lb + strlen("<")));
560 date = xmemdupz(rb + strlen("> "), eol - (rb + strlen("> ")));
563 if (force_author) {
564 const char *lb = strstr(force_author, " <");
565 const char *rb = strchr(force_author, '>');
567 if (!lb || !rb)
568 die(_("malformed --author parameter"));
569 name = xstrndup(force_author, lb - force_author);
570 email = xstrndup(lb + 2, rb - (lb + 2));
573 if (force_date)
574 date = force_date;
575 strbuf_addstr(author_ident, fmt_ident(name, email, date,
576 IDENT_ERROR_ON_NO_NAME));
579 static int ends_rfc2822_footer(struct strbuf *sb)
581 int ch;
582 int hit = 0;
583 int i, j, k;
584 int len = sb->len;
585 int first = 1;
586 const char *buf = sb->buf;
588 for (i = len - 1; i > 0; i--) {
589 if (hit && buf[i] == '\n')
590 break;
591 hit = (buf[i] == '\n');
594 while (i < len - 1 && buf[i] == '\n')
595 i++;
597 for (; i < len; i = k) {
598 for (k = i; k < len && buf[k] != '\n'; k++)
599 ; /* do nothing */
600 k++;
602 if ((buf[k] == ' ' || buf[k] == '\t') && !first)
603 continue;
605 first = 0;
607 for (j = 0; i + j < len; j++) {
608 ch = buf[i + j];
609 if (ch == ':')
610 break;
611 if (isalnum(ch) ||
612 (ch == '-'))
613 continue;
614 return 0;
617 return 1;
620 static char *cut_ident_timestamp_part(char *string)
622 char *ket = strrchr(string, '>');
623 if (!ket || ket[1] != ' ')
624 die(_("Malformed ident string: '%s'"), string);
625 *++ket = '\0';
626 return ket;
629 static int prepare_to_commit(const char *index_file, const char *prefix,
630 struct commit *current_head,
631 struct wt_status *s,
632 struct strbuf *author_ident)
634 struct stat statbuf;
635 struct strbuf committer_ident = STRBUF_INIT;
636 int commitable, saved_color_setting;
637 struct strbuf sb = STRBUF_INIT;
638 char *buffer;
639 const char *hook_arg1 = NULL;
640 const char *hook_arg2 = NULL;
641 int ident_shown = 0;
642 int clean_message_contents = (cleanup_mode != CLEANUP_NONE);
644 if (!no_verify && run_hook(index_file, "pre-commit", NULL))
645 return 0;
647 if (squash_message) {
649 * Insert the proper subject line before other commit
650 * message options add their content.
652 if (use_message && !strcmp(use_message, squash_message))
653 strbuf_addstr(&sb, "squash! ");
654 else {
655 struct pretty_print_context ctx = {0};
656 struct commit *c;
657 c = lookup_commit_reference_by_name(squash_message);
658 if (!c)
659 die(_("could not lookup commit %s"), squash_message);
660 ctx.output_encoding = get_commit_output_encoding();
661 format_commit_message(c, "squash! %s\n\n", &sb,
662 &ctx);
666 if (message.len) {
667 strbuf_addbuf(&sb, &message);
668 hook_arg1 = "message";
669 } else if (logfile && !strcmp(logfile, "-")) {
670 if (isatty(0))
671 fprintf(stderr, _("(reading log message from standard input)\n"));
672 if (strbuf_read(&sb, 0, 0) < 0)
673 die_errno(_("could not read log from standard input"));
674 hook_arg1 = "message";
675 } else if (logfile) {
676 if (strbuf_read_file(&sb, logfile, 0) < 0)
677 die_errno(_("could not read log file '%s'"),
678 logfile);
679 hook_arg1 = "message";
680 } else if (use_message) {
681 buffer = strstr(use_message_buffer, "\n\n");
682 if (!buffer || buffer[2] == '\0')
683 die(_("commit has empty message"));
684 strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
685 hook_arg1 = "commit";
686 hook_arg2 = use_message;
687 } else if (fixup_message) {
688 struct pretty_print_context ctx = {0};
689 struct commit *commit;
690 commit = lookup_commit_reference_by_name(fixup_message);
691 if (!commit)
692 die(_("could not lookup commit %s"), fixup_message);
693 ctx.output_encoding = get_commit_output_encoding();
694 format_commit_message(commit, "fixup! %s\n\n",
695 &sb, &ctx);
696 hook_arg1 = "message";
697 } else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
698 if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
699 die_errno(_("could not read MERGE_MSG"));
700 hook_arg1 = "merge";
701 } else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
702 if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
703 die_errno(_("could not read SQUASH_MSG"));
704 hook_arg1 = "squash";
705 } else if (template_file) {
706 if (strbuf_read_file(&sb, template_file, 0) < 0)
707 die_errno(_("could not read '%s'"), template_file);
708 hook_arg1 = "template";
709 clean_message_contents = 0;
713 * The remaining cases don't modify the template message, but
714 * just set the argument(s) to the prepare-commit-msg hook.
716 else if (whence == FROM_MERGE)
717 hook_arg1 = "merge";
718 else if (whence == FROM_CHERRY_PICK) {
719 hook_arg1 = "commit";
720 hook_arg2 = "CHERRY_PICK_HEAD";
723 if (squash_message) {
725 * If squash_commit was used for the commit subject,
726 * then we're possibly hijacking other commit log options.
727 * Reset the hook args to tell the real story.
729 hook_arg1 = "message";
730 hook_arg2 = "";
733 s->fp = fopen(git_path(commit_editmsg), "w");
734 if (s->fp == NULL)
735 die_errno(_("could not open '%s'"), git_path(commit_editmsg));
737 if (clean_message_contents)
738 stripspace(&sb, 0);
740 if (signoff) {
741 struct strbuf sob = STRBUF_INIT;
742 int i;
744 strbuf_addstr(&sob, sign_off_header);
745 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
746 getenv("GIT_COMMITTER_EMAIL")));
747 strbuf_addch(&sob, '\n');
748 for (i = sb.len - 1; i > 0 && sb.buf[i - 1] != '\n'; i--)
749 ; /* do nothing */
750 if (prefixcmp(sb.buf + i, sob.buf)) {
751 if (!i || !ends_rfc2822_footer(&sb))
752 strbuf_addch(&sb, '\n');
753 strbuf_addbuf(&sb, &sob);
755 strbuf_release(&sob);
758 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
759 die_errno(_("could not write commit template"));
761 strbuf_release(&sb);
763 /* This checks and barfs if author is badly specified */
764 determine_author_info(author_ident);
766 /* This checks if committer ident is explicitly given */
767 strbuf_addstr(&committer_ident, git_committer_info(0));
768 if (use_editor && include_status) {
769 char *ai_tmp, *ci_tmp;
770 if (whence != FROM_COMMIT)
771 status_printf_ln(s, GIT_COLOR_NORMAL,
772 _("\n"
773 "It looks like you may be committing a %s.\n"
774 "If this is not correct, please remove the file\n"
775 " %s\n"
776 "and try again.\n"
777 ""),
778 whence_s(),
779 git_path(whence == FROM_MERGE
780 ? "MERGE_HEAD"
781 : "CHERRY_PICK_HEAD"));
783 fprintf(s->fp, "\n");
784 status_printf(s, GIT_COLOR_NORMAL,
785 _("Please enter the commit message for your changes."));
786 if (cleanup_mode == CLEANUP_ALL)
787 status_printf_more(s, GIT_COLOR_NORMAL,
788 _(" Lines starting\n"
789 "with '#' will be ignored, and an empty"
790 " message aborts the commit.\n"));
791 else /* CLEANUP_SPACE, that is. */
792 status_printf_more(s, GIT_COLOR_NORMAL,
793 _(" Lines starting\n"
794 "with '#' will be kept; you may remove them"
795 " yourself if you want to.\n"
796 "An empty message aborts the commit.\n"));
797 if (only_include_assumed)
798 status_printf_ln(s, GIT_COLOR_NORMAL,
799 "%s", only_include_assumed);
801 ai_tmp = cut_ident_timestamp_part(author_ident->buf);
802 ci_tmp = cut_ident_timestamp_part(committer_ident.buf);
803 if (strcmp(author_ident->buf, committer_ident.buf))
804 status_printf_ln(s, GIT_COLOR_NORMAL,
805 _("%s"
806 "Author: %s"),
807 ident_shown++ ? "" : "\n",
808 author_ident->buf);
810 if (!user_ident_sufficiently_given())
811 status_printf_ln(s, GIT_COLOR_NORMAL,
812 _("%s"
813 "Committer: %s"),
814 ident_shown++ ? "" : "\n",
815 committer_ident.buf);
817 if (ident_shown)
818 status_printf_ln(s, GIT_COLOR_NORMAL, "");
820 saved_color_setting = s->use_color;
821 s->use_color = 0;
822 commitable = run_status(s->fp, index_file, prefix, 1, s);
823 s->use_color = saved_color_setting;
825 *ai_tmp = ' ';
826 *ci_tmp = ' ';
827 } else {
828 unsigned char sha1[20];
829 const char *parent = "HEAD";
831 if (!active_nr && read_cache() < 0)
832 die(_("Cannot read index"));
834 if (amend)
835 parent = "HEAD^1";
837 if (get_sha1(parent, sha1))
838 commitable = !!active_nr;
839 else
840 commitable = index_differs_from(parent, 0);
842 strbuf_release(&committer_ident);
844 fclose(s->fp);
847 * Reject an attempt to record a non-merge empty commit without
848 * explicit --allow-empty. In the cherry-pick case, it may be
849 * empty due to conflict resolution, which the user should okay.
851 if (!commitable && whence != FROM_MERGE && !allow_empty &&
852 !(amend && is_a_merge(current_head))) {
853 run_status(stdout, index_file, prefix, 0, s);
854 if (amend)
855 fputs(_(empty_amend_advice), stderr);
856 else if (whence == FROM_CHERRY_PICK)
857 fputs(_(empty_cherry_pick_advice), stderr);
858 return 0;
862 * Re-read the index as pre-commit hook could have updated it,
863 * and write it out as a tree. We must do this before we invoke
864 * the editor and after we invoke run_status above.
866 discard_cache();
867 read_cache_from(index_file);
868 if (update_main_cache_tree(0)) {
869 error(_("Error building trees"));
870 return 0;
873 if (run_hook(index_file, "prepare-commit-msg",
874 git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
875 return 0;
877 if (use_editor) {
878 char index[PATH_MAX];
879 const char *env[2] = { NULL };
880 env[0] = index;
881 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
882 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
883 fprintf(stderr,
884 _("Please supply the message using either -m or -F option.\n"));
885 exit(1);
889 if (!no_verify &&
890 run_hook(index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
891 return 0;
894 return 1;
898 * Find out if the message in the strbuf contains only whitespace and
899 * Signed-off-by lines.
901 static int message_is_empty(struct strbuf *sb)
903 struct strbuf tmpl = STRBUF_INIT;
904 const char *nl;
905 int eol, i, start = 0;
907 if (cleanup_mode == CLEANUP_NONE && sb->len)
908 return 0;
910 /* See if the template is just a prefix of the message. */
911 if (template_file && strbuf_read_file(&tmpl, template_file, 0) > 0) {
912 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
913 if (start + tmpl.len <= sb->len &&
914 memcmp(tmpl.buf, sb->buf + start, tmpl.len) == 0)
915 start += tmpl.len;
917 strbuf_release(&tmpl);
919 /* Check if the rest is just whitespace and Signed-of-by's. */
920 for (i = start; i < sb->len; i++) {
921 nl = memchr(sb->buf + i, '\n', sb->len - i);
922 if (nl)
923 eol = nl - sb->buf;
924 else
925 eol = sb->len;
927 if (strlen(sign_off_header) <= eol - i &&
928 !prefixcmp(sb->buf + i, sign_off_header)) {
929 i = eol;
930 continue;
932 while (i < eol)
933 if (!isspace(sb->buf[i++]))
934 return 0;
937 return 1;
940 static const char *find_author_by_nickname(const char *name)
942 struct rev_info revs;
943 struct commit *commit;
944 struct strbuf buf = STRBUF_INIT;
945 const char *av[20];
946 int ac = 0;
948 init_revisions(&revs, NULL);
949 strbuf_addf(&buf, "--author=%s", name);
950 av[++ac] = "--all";
951 av[++ac] = "-i";
952 av[++ac] = buf.buf;
953 av[++ac] = NULL;
954 setup_revisions(ac, av, &revs, NULL);
955 prepare_revision_walk(&revs);
956 commit = get_revision(&revs);
957 if (commit) {
958 struct pretty_print_context ctx = {0};
959 ctx.date_mode = DATE_NORMAL;
960 strbuf_release(&buf);
961 format_commit_message(commit, "%an <%ae>", &buf, &ctx);
962 return strbuf_detach(&buf, NULL);
964 die(_("No existing author found with '%s'"), name);
968 static void handle_untracked_files_arg(struct wt_status *s)
970 if (!untracked_files_arg)
971 ; /* default already initialized */
972 else if (!strcmp(untracked_files_arg, "no"))
973 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
974 else if (!strcmp(untracked_files_arg, "normal"))
975 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
976 else if (!strcmp(untracked_files_arg, "all"))
977 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
978 else
979 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
982 static const char *read_commit_message(const char *name)
984 const char *out_enc, *out;
985 struct commit *commit;
987 commit = lookup_commit_reference_by_name(name);
988 if (!commit)
989 die(_("could not lookup commit %s"), name);
990 out_enc = get_commit_output_encoding();
991 out = logmsg_reencode(commit, out_enc);
994 * If we failed to reencode the buffer, just copy it
995 * byte for byte so the user can try to fix it up.
996 * This also handles the case where input and output
997 * encodings are identical.
999 if (out == NULL)
1000 out = xstrdup(commit->buffer);
1001 return out;
1004 static int parse_and_validate_options(int argc, const char *argv[],
1005 const char * const usage[],
1006 const char *prefix,
1007 struct commit *current_head,
1008 struct wt_status *s)
1010 int f = 0;
1012 argc = parse_options(argc, argv, prefix, builtin_commit_options, usage,
1015 if (force_author && !strchr(force_author, '>'))
1016 force_author = find_author_by_nickname(force_author);
1018 if (force_author && renew_authorship)
1019 die(_("Using both --reset-author and --author does not make sense"));
1021 if (logfile || message.len || use_message || fixup_message)
1022 use_editor = 0;
1023 if (0 <= edit_flag)
1024 use_editor = edit_flag;
1025 if (!use_editor)
1026 setenv("GIT_EDITOR", ":", 1);
1028 /* Sanity check options */
1029 if (amend && !current_head)
1030 die(_("You have nothing to amend."));
1031 if (amend && whence != FROM_COMMIT)
1032 die(_("You are in the middle of a %s -- cannot amend."), whence_s());
1033 if (fixup_message && squash_message)
1034 die(_("Options --squash and --fixup cannot be used together"));
1035 if (use_message)
1036 f++;
1037 if (edit_message)
1038 f++;
1039 if (fixup_message)
1040 f++;
1041 if (logfile)
1042 f++;
1043 if (f > 1)
1044 die(_("Only one of -c/-C/-F/--fixup can be used."));
1045 if (message.len && f > 0)
1046 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1047 if (edit_message)
1048 use_message = edit_message;
1049 if (amend && !use_message && !fixup_message)
1050 use_message = "HEAD";
1051 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
1052 die(_("--reset-author can be used only with -C, -c or --amend."));
1053 if (use_message) {
1054 use_message_buffer = read_commit_message(use_message);
1055 if (!renew_authorship) {
1056 author_message = use_message;
1057 author_message_buffer = use_message_buffer;
1060 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1061 author_message = "CHERRY_PICK_HEAD";
1062 author_message_buffer = read_commit_message(author_message);
1065 if (patch_interactive)
1066 interactive = 1;
1068 if (!!also + !!only + !!all + !!interactive > 1)
1069 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1070 if (argc == 0 && (also || (only && !amend)))
1071 die(_("No paths with --include/--only does not make sense."));
1072 if (argc == 0 && only && amend)
1073 only_include_assumed = _("Clever... amending the last one with dirty index.");
1074 if (argc > 0 && !also && !only)
1075 only_include_assumed = _("Explicit paths specified without -i nor -o; assuming --only paths...");
1076 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1077 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1078 else if (!strcmp(cleanup_arg, "verbatim"))
1079 cleanup_mode = CLEANUP_NONE;
1080 else if (!strcmp(cleanup_arg, "whitespace"))
1081 cleanup_mode = CLEANUP_SPACE;
1082 else if (!strcmp(cleanup_arg, "strip"))
1083 cleanup_mode = CLEANUP_ALL;
1084 else
1085 die(_("Invalid cleanup mode %s"), cleanup_arg);
1087 handle_untracked_files_arg(s);
1089 if (all && argc > 0)
1090 die(_("Paths with -a does not make sense."));
1092 if (null_termination && status_format == STATUS_FORMAT_LONG)
1093 status_format = STATUS_FORMAT_PORCELAIN;
1094 if (status_format != STATUS_FORMAT_LONG)
1095 dry_run = 1;
1097 return argc;
1100 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1101 const struct commit *current_head, struct wt_status *s)
1103 int commitable;
1104 const char *index_file;
1106 index_file = prepare_index(argc, argv, prefix, current_head, 1);
1107 commitable = run_status(stdout, index_file, prefix, 0, s);
1108 rollback_index_files();
1110 return commitable ? 0 : 1;
1113 static int parse_status_slot(const char *var, int offset)
1115 if (!strcasecmp(var+offset, "header"))
1116 return WT_STATUS_HEADER;
1117 if (!strcasecmp(var+offset, "branch"))
1118 return WT_STATUS_ONBRANCH;
1119 if (!strcasecmp(var+offset, "updated")
1120 || !strcasecmp(var+offset, "added"))
1121 return WT_STATUS_UPDATED;
1122 if (!strcasecmp(var+offset, "changed"))
1123 return WT_STATUS_CHANGED;
1124 if (!strcasecmp(var+offset, "untracked"))
1125 return WT_STATUS_UNTRACKED;
1126 if (!strcasecmp(var+offset, "nobranch"))
1127 return WT_STATUS_NOBRANCH;
1128 if (!strcasecmp(var+offset, "unmerged"))
1129 return WT_STATUS_UNMERGED;
1130 return -1;
1133 static int git_status_config(const char *k, const char *v, void *cb)
1135 struct wt_status *s = cb;
1137 if (!strcmp(k, "status.submodulesummary")) {
1138 int is_bool;
1139 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1140 if (is_bool && s->submodule_summary)
1141 s->submodule_summary = -1;
1142 return 0;
1144 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1145 s->use_color = git_config_colorbool(k, v);
1146 return 0;
1148 if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
1149 int slot = parse_status_slot(k, 13);
1150 if (slot < 0)
1151 return 0;
1152 if (!v)
1153 return config_error_nonbool(k);
1154 color_parse(v, k, s->color_palette[slot]);
1155 return 0;
1157 if (!strcmp(k, "status.relativepaths")) {
1158 s->relative_paths = git_config_bool(k, v);
1159 return 0;
1161 if (!strcmp(k, "status.showuntrackedfiles")) {
1162 if (!v)
1163 return config_error_nonbool(k);
1164 else if (!strcmp(v, "no"))
1165 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1166 else if (!strcmp(v, "normal"))
1167 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1168 else if (!strcmp(v, "all"))
1169 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1170 else
1171 return error(_("Invalid untracked files mode '%s'"), v);
1172 return 0;
1174 return git_diff_ui_config(k, v, NULL);
1177 int cmd_status(int argc, const char **argv, const char *prefix)
1179 struct wt_status s;
1180 int fd;
1181 unsigned char sha1[20];
1182 static struct option builtin_status_options[] = {
1183 OPT__VERBOSE(&verbose, "be verbose"),
1184 OPT_SET_INT('s', "short", &status_format,
1185 "show status concisely", STATUS_FORMAT_SHORT),
1186 OPT_BOOLEAN('b', "branch", &status_show_branch,
1187 "show branch information"),
1188 OPT_SET_INT(0, "porcelain", &status_format,
1189 "machine-readable output",
1190 STATUS_FORMAT_PORCELAIN),
1191 OPT_BOOLEAN('z', "null", &null_termination,
1192 "terminate entries with NUL"),
1193 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1194 "mode",
1195 "show untracked files, optional modes: all, normal, no. (Default: all)",
1196 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1197 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status,
1198 "show ignored files"),
1199 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, "when",
1200 "ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)",
1201 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1202 OPT_END(),
1205 if (argc == 2 && !strcmp(argv[1], "-h"))
1206 usage_with_options(builtin_status_usage, builtin_status_options);
1208 wt_status_prepare(&s);
1209 gitmodules_config();
1210 git_config(git_status_config, &s);
1211 determine_whence(&s);
1212 argc = parse_options(argc, argv, prefix,
1213 builtin_status_options,
1214 builtin_status_usage, 0);
1216 if (null_termination && status_format == STATUS_FORMAT_LONG)
1217 status_format = STATUS_FORMAT_PORCELAIN;
1219 handle_untracked_files_arg(&s);
1220 if (show_ignored_in_status)
1221 s.show_ignored_files = 1;
1222 if (*argv)
1223 s.pathspec = get_pathspec(prefix, argv);
1225 read_cache_preload(s.pathspec);
1226 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);
1228 fd = hold_locked_index(&index_lock, 0);
1229 if (0 <= fd)
1230 update_index_if_able(&the_index, &index_lock);
1232 s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1233 s.ignore_submodule_arg = ignore_submodule_arg;
1234 wt_status_collect(&s);
1236 if (s.relative_paths)
1237 s.prefix = prefix;
1239 switch (status_format) {
1240 case STATUS_FORMAT_SHORT:
1241 wt_shortstatus_print(&s, null_termination, status_show_branch);
1242 break;
1243 case STATUS_FORMAT_PORCELAIN:
1244 wt_porcelain_print(&s, null_termination);
1245 break;
1246 case STATUS_FORMAT_LONG:
1247 s.verbose = verbose;
1248 s.ignore_submodule_arg = ignore_submodule_arg;
1249 wt_status_print(&s);
1250 break;
1252 return 0;
1255 static void print_summary(const char *prefix, const unsigned char *sha1,
1256 int initial_commit)
1258 struct rev_info rev;
1259 struct commit *commit;
1260 struct strbuf format = STRBUF_INIT;
1261 unsigned char junk_sha1[20];
1262 const char *head;
1263 struct pretty_print_context pctx = {0};
1264 struct strbuf author_ident = STRBUF_INIT;
1265 struct strbuf committer_ident = STRBUF_INIT;
1267 commit = lookup_commit(sha1);
1268 if (!commit)
1269 die(_("couldn't look up newly created commit"));
1270 if (!commit || parse_commit(commit))
1271 die(_("could not parse newly created commit"));
1273 strbuf_addstr(&format, "format:%h] %s");
1275 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1276 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1277 if (strbuf_cmp(&author_ident, &committer_ident)) {
1278 strbuf_addstr(&format, "\n Author: ");
1279 strbuf_addbuf_percentquote(&format, &author_ident);
1281 if (!user_ident_sufficiently_given()) {
1282 strbuf_addstr(&format, "\n Committer: ");
1283 strbuf_addbuf_percentquote(&format, &committer_ident);
1284 if (advice_implicit_identity) {
1285 strbuf_addch(&format, '\n');
1286 strbuf_addstr(&format, _(implicit_ident_advice));
1289 strbuf_release(&author_ident);
1290 strbuf_release(&committer_ident);
1292 init_revisions(&rev, prefix);
1293 setup_revisions(0, NULL, &rev, NULL);
1295 rev.diff = 1;
1296 rev.diffopt.output_format =
1297 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1299 rev.verbose_header = 1;
1300 rev.show_root_diff = 1;
1301 get_commit_format(format.buf, &rev);
1302 rev.always_show_header = 0;
1303 rev.diffopt.detect_rename = 1;
1304 rev.diffopt.break_opt = 0;
1305 diff_setup_done(&rev.diffopt);
1307 head = resolve_ref("HEAD", junk_sha1, 0, NULL);
1308 printf("[%s%s ",
1309 !prefixcmp(head, "refs/heads/") ?
1310 head + 11 :
1311 !strcmp(head, "HEAD") ?
1312 _("detached HEAD") :
1313 head,
1314 initial_commit ? _(" (root-commit)") : "");
1316 if (!log_tree_commit(&rev, commit)) {
1317 rev.always_show_header = 1;
1318 rev.use_terminator = 1;
1319 log_tree_commit(&rev, commit);
1322 strbuf_release(&format);
1325 static int git_commit_config(const char *k, const char *v, void *cb)
1327 struct wt_status *s = cb;
1329 if (!strcmp(k, "commit.template"))
1330 return git_config_pathname(&template_file, k, v);
1331 if (!strcmp(k, "commit.status")) {
1332 include_status = git_config_bool(k, v);
1333 return 0;
1336 return git_status_config(k, v, s);
1339 static const char post_rewrite_hook[] = "hooks/post-rewrite";
1341 static int run_rewrite_hook(const unsigned char *oldsha1,
1342 const unsigned char *newsha1)
1344 /* oldsha1 SP newsha1 LF NUL */
1345 static char buf[2*40 + 3];
1346 struct child_process proc;
1347 const char *argv[3];
1348 int code;
1349 size_t n;
1351 if (access(git_path(post_rewrite_hook), X_OK) < 0)
1352 return 0;
1354 argv[0] = git_path(post_rewrite_hook);
1355 argv[1] = "amend";
1356 argv[2] = NULL;
1358 memset(&proc, 0, sizeof(proc));
1359 proc.argv = argv;
1360 proc.in = -1;
1361 proc.stdout_to_stderr = 1;
1363 code = start_command(&proc);
1364 if (code)
1365 return code;
1366 n = snprintf(buf, sizeof(buf), "%s %s\n",
1367 sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1368 write_in_full(proc.in, buf, n);
1369 close(proc.in);
1370 return finish_command(&proc);
1373 int cmd_commit(int argc, const char **argv, const char *prefix)
1375 struct strbuf sb = STRBUF_INIT;
1376 struct strbuf author_ident = STRBUF_INIT;
1377 const char *index_file, *reflog_msg;
1378 char *nl, *p;
1379 unsigned char sha1[20];
1380 struct ref_lock *ref_lock;
1381 struct commit_list *parents = NULL, **pptr = &parents;
1382 struct stat statbuf;
1383 int allow_fast_forward = 1;
1384 struct wt_status s;
1385 struct commit *current_head = NULL;
1386 struct commit_extra_header *extra = NULL;
1388 if (argc == 2 && !strcmp(argv[1], "-h"))
1389 usage_with_options(builtin_commit_usage, builtin_commit_options);
1391 wt_status_prepare(&s);
1392 git_config(git_commit_config, &s);
1393 determine_whence(&s);
1395 if (get_sha1("HEAD", sha1))
1396 current_head = NULL;
1397 else {
1398 current_head = lookup_commit_or_die(sha1, "HEAD");
1399 if (!current_head || parse_commit(current_head))
1400 die(_("could not parse HEAD commit"));
1402 argc = parse_and_validate_options(argc, argv, builtin_commit_usage,
1403 prefix, current_head, &s);
1404 if (dry_run)
1405 return dry_run_commit(argc, argv, prefix, current_head, &s);
1406 index_file = prepare_index(argc, argv, prefix, current_head, 0);
1408 /* Set up everything for writing the commit object. This includes
1409 running hooks, writing the trees, and interacting with the user. */
1410 if (!prepare_to_commit(index_file, prefix,
1411 current_head, &s, &author_ident)) {
1412 rollback_index_files();
1413 return 1;
1416 /* Determine parents */
1417 reflog_msg = getenv("GIT_REFLOG_ACTION");
1418 if (!current_head) {
1419 if (!reflog_msg)
1420 reflog_msg = "commit (initial)";
1421 } else if (amend) {
1422 struct commit_list *c;
1424 if (!reflog_msg)
1425 reflog_msg = "commit (amend)";
1426 for (c = current_head->parents; c; c = c->next)
1427 pptr = &commit_list_insert(c->item, pptr)->next;
1428 } else if (whence == FROM_MERGE) {
1429 struct strbuf m = STRBUF_INIT;
1430 FILE *fp;
1432 if (!reflog_msg)
1433 reflog_msg = "commit (merge)";
1434 pptr = &commit_list_insert(current_head, pptr)->next;
1435 fp = fopen(git_path("MERGE_HEAD"), "r");
1436 if (fp == NULL)
1437 die_errno(_("could not open '%s' for reading"),
1438 git_path("MERGE_HEAD"));
1439 while (strbuf_getline(&m, fp, '\n') != EOF) {
1440 struct commit *parent;
1442 parent = get_merge_parent(m.buf);
1443 if (!parent)
1444 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1445 pptr = &commit_list_insert(parent, pptr)->next;
1447 fclose(fp);
1448 strbuf_release(&m);
1449 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1450 if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1451 die_errno(_("could not read MERGE_MODE"));
1452 if (!strcmp(sb.buf, "no-ff"))
1453 allow_fast_forward = 0;
1455 if (allow_fast_forward)
1456 parents = reduce_heads(parents);
1457 } else {
1458 if (!reflog_msg)
1459 reflog_msg = (whence == FROM_CHERRY_PICK)
1460 ? "commit (cherry-pick)"
1461 : "commit";
1462 pptr = &commit_list_insert(current_head, pptr)->next;
1465 /* Finally, get the commit message */
1466 strbuf_reset(&sb);
1467 if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1468 int saved_errno = errno;
1469 rollback_index_files();
1470 die(_("could not read commit message: %s"), strerror(saved_errno));
1473 /* Truncate the message just before the diff, if any. */
1474 if (verbose) {
1475 p = strstr(sb.buf, "\ndiff --git ");
1476 if (p != NULL)
1477 strbuf_setlen(&sb, p - sb.buf + 1);
1480 if (cleanup_mode != CLEANUP_NONE)
1481 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1482 if (message_is_empty(&sb) && !allow_empty_message) {
1483 rollback_index_files();
1484 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
1485 exit(1);
1488 if (amend)
1489 extra = read_commit_extra_headers(current_head);
1491 if (commit_tree_extended(sb.buf, active_cache_tree->sha1, parents, sha1,
1492 author_ident.buf, extra)) {
1493 rollback_index_files();
1494 die(_("failed to write commit object"));
1496 strbuf_release(&author_ident);
1497 free_commit_extra_headers(extra);
1499 ref_lock = lock_any_ref_for_update("HEAD",
1500 !current_head
1501 ? NULL
1502 : current_head->object.sha1,
1505 nl = strchr(sb.buf, '\n');
1506 if (nl)
1507 strbuf_setlen(&sb, nl + 1 - sb.buf);
1508 else
1509 strbuf_addch(&sb, '\n');
1510 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1511 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1513 if (!ref_lock) {
1514 rollback_index_files();
1515 die(_("cannot lock HEAD ref"));
1517 if (write_ref_sha1(ref_lock, sha1, sb.buf) < 0) {
1518 rollback_index_files();
1519 die(_("cannot update HEAD ref"));
1522 unlink(git_path("CHERRY_PICK_HEAD"));
1523 unlink(git_path("REVERT_HEAD"));
1524 unlink(git_path("MERGE_HEAD"));
1525 unlink(git_path("MERGE_MSG"));
1526 unlink(git_path("MERGE_MODE"));
1527 unlink(git_path("SQUASH_MSG"));
1529 if (commit_index_files())
1530 die (_("Repository has been updated, but unable to write\n"
1531 "new_index file. Check that disk is not full or quota is\n"
1532 "not exceeded, and then \"git reset HEAD\" to recover."));
1534 rerere(0);
1535 run_hook(get_index_file(), "post-commit", NULL);
1536 if (amend && !no_post_rewrite) {
1537 struct notes_rewrite_cfg *cfg;
1538 cfg = init_copy_notes_for_rewrite("amend");
1539 if (cfg) {
1540 /* we are amending, so current_head is not NULL */
1541 copy_note_for_rewrite(cfg, current_head->object.sha1, sha1);
1542 finish_copy_notes_for_rewrite(cfg);
1544 run_rewrite_hook(current_head->object.sha1, sha1);
1546 if (!quiet)
1547 print_summary(prefix, sha1, !current_head);
1549 return 0;