4 * Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>
5 * Based on git-commit.sh by Junio C Hamano and Linus Torvalds
9 #include "cache-tree.h"
17 #include "wt-status.h"
18 #include "run-command.h"
23 #include "parse-options.h"
24 #include "string-list.h"
26 #include "unpack-trees.h"
28 #include "submodule.h"
30 static const char * const builtin_commit_usage
[] = {
31 "git commit [options] [--] <filepattern>...",
35 static const char * const builtin_status_usage
[] = {
36 "git status [options] [--] <filepattern>...",
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"
45 " git config --global user.name \"Your Name\"\n"
46 " git config --global user.email you@example.com\n"
48 "After doing this, you may fix the identity used for this commit with:\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"
61 " git commit --allow-empty\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 */
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
, edit_flag
, also
, interactive
, patch_interactive
, only
, amend
, signoff
;
85 static int quiet
, verbose
, no_verify
, allow_empty
, dry_run
, renew_authorship
;
86 static int no_post_rewrite
, allow_empty_message
;
87 static char *untracked_files_arg
, *force_date
, *ignore_submodule_arg
;
89 * The default commit message cleanup mode will remove the lines
90 * beginning with # (shell comments) and leading and trailing
91 * whitespaces (empty lines or containing only whitespaces)
92 * if editor is used, and only the whitespaces if the message
93 * is specified explicitly.
100 static char *cleanup_arg
;
102 static enum commit_whence whence
;
103 static int use_editor
= 1, include_status
= 1;
104 static int show_ignored_in_status
;
105 static const char *only_include_assumed
;
106 static struct strbuf message
= STRBUF_INIT
;
108 static int null_termination
;
112 STATUS_FORMAT_PORCELAIN
113 } status_format
= STATUS_FORMAT_LONG
;
114 static int status_show_branch
;
116 static int opt_parse_m(const struct option
*opt
, const char *arg
, int unset
)
118 struct strbuf
*buf
= opt
->value
;
120 strbuf_setlen(buf
, 0);
122 strbuf_addstr(buf
, arg
);
123 strbuf_addstr(buf
, "\n\n");
128 static struct option builtin_commit_options
[] = {
129 OPT__QUIET(&quiet
, "suppress summary after successful commit"),
130 OPT__VERBOSE(&verbose
, "show diff in commit message template"),
132 OPT_GROUP("Commit message options"),
133 OPT_FILENAME('F', "file", &logfile
, "read message from file"),
134 OPT_STRING(0, "author", &force_author
, "author", "override author for commit"),
135 OPT_STRING(0, "date", &force_date
, "date", "override date for commit"),
136 OPT_CALLBACK('m', "message", &message
, "message", "commit message", opt_parse_m
),
137 OPT_STRING('c', "reedit-message", &edit_message
, "commit", "reuse and edit message from specified commit"),
138 OPT_STRING('C', "reuse-message", &use_message
, "commit", "reuse message from specified commit"),
139 OPT_STRING(0, "fixup", &fixup_message
, "commit", "use autosquash formatted message to fixup specified commit"),
140 OPT_STRING(0, "squash", &squash_message
, "commit", "use autosquash formatted message to squash specified commit"),
141 OPT_BOOLEAN(0, "reset-author", &renew_authorship
, "the commit is authored by me now (used with -C/-c/--amend)"),
142 OPT_BOOLEAN('s', "signoff", &signoff
, "add Signed-off-by:"),
143 OPT_FILENAME('t', "template", &template_file
, "use specified template file"),
144 OPT_BOOLEAN('e', "edit", &edit_flag
, "force edit of commit"),
145 OPT_STRING(0, "cleanup", &cleanup_arg
, "default", "how to strip spaces and #comments from message"),
146 OPT_BOOLEAN(0, "status", &include_status
, "include status in commit message template"),
147 /* end commit message options */
149 OPT_GROUP("Commit contents options"),
150 OPT_BOOLEAN('a', "all", &all
, "commit all changed files"),
151 OPT_BOOLEAN('i', "include", &also
, "add specified files to index for commit"),
152 OPT_BOOLEAN(0, "interactive", &interactive
, "interactively add files"),
153 OPT_BOOLEAN('p', "patch", &patch_interactive
, "interactively add changes"),
154 OPT_BOOLEAN('o', "only", &only
, "commit only specified files"),
155 OPT_BOOLEAN('n', "no-verify", &no_verify
, "bypass pre-commit hook"),
156 OPT_BOOLEAN(0, "dry-run", &dry_run
, "show what would be committed"),
157 OPT_SET_INT(0, "short", &status_format
, "show status concisely",
158 STATUS_FORMAT_SHORT
),
159 OPT_BOOLEAN(0, "branch", &status_show_branch
, "show branch information"),
160 OPT_SET_INT(0, "porcelain", &status_format
,
161 "machine-readable output", STATUS_FORMAT_PORCELAIN
),
162 OPT_BOOLEAN('z', "null", &null_termination
,
163 "terminate entries with NUL"),
164 OPT_BOOLEAN(0, "amend", &amend
, "amend previous commit"),
165 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite
, "bypass post-rewrite hook"),
166 { 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" },
167 /* end commit contents options */
169 { OPTION_BOOLEAN
, 0, "allow-empty", &allow_empty
, NULL
,
170 "ok to record an empty change",
171 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
172 { OPTION_BOOLEAN
, 0, "allow-empty-message", &allow_empty_message
, NULL
,
173 "ok to record a change with an empty message",
174 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
179 static void determine_whence(struct wt_status
*s
)
181 if (file_exists(git_path("MERGE_HEAD")))
183 else if (file_exists(git_path("CHERRY_PICK_HEAD")))
184 whence
= FROM_CHERRY_PICK
;
186 whence
= FROM_COMMIT
;
191 static const char *whence_s(void)
201 case FROM_CHERRY_PICK
:
209 static void rollback_index_files(void)
211 switch (commit_style
) {
213 break; /* nothing to do */
215 rollback_lock_file(&index_lock
);
218 rollback_lock_file(&index_lock
);
219 rollback_lock_file(&false_lock
);
224 static int commit_index_files(void)
228 switch (commit_style
) {
230 break; /* nothing to do */
232 err
= commit_lock_file(&index_lock
);
235 err
= commit_lock_file(&index_lock
);
236 rollback_lock_file(&false_lock
);
244 * Take a union of paths in the index and the named tree (typically, "HEAD"),
245 * and return the paths that match the given pattern in list.
247 static int list_paths(struct string_list
*list
, const char *with_tree
,
248 const char *prefix
, const char **pattern
)
253 for (i
= 0; pattern
[i
]; i
++)
258 char *max_prefix
= common_prefix(pattern
);
259 overlay_tree_on_cache(with_tree
, max_prefix
? max_prefix
: prefix
);
263 for (i
= 0; i
< active_nr
; i
++) {
264 struct cache_entry
*ce
= active_cache
[i
];
265 struct string_list_item
*item
;
267 if (ce
->ce_flags
& CE_UPDATE
)
269 if (!match_pathspec(pattern
, ce
->name
, ce_namelen(ce
), 0, m
))
271 item
= string_list_insert(list
, ce
->name
);
272 if (ce_skip_worktree(ce
))
273 item
->util
= item
; /* better a valid pointer than a fake one */
276 return report_path_error(m
, pattern
, prefix
);
279 static void add_remove_files(struct string_list
*list
)
282 for (i
= 0; i
< list
->nr
; i
++) {
284 struct string_list_item
*p
= &(list
->items
[i
]);
286 /* p->util is skip-worktree */
290 if (!lstat(p
->string
, &st
)) {
291 if (add_to_cache(p
->string
, &st
, 0))
292 die(_("updating files failed"));
294 remove_file_from_cache(p
->string
);
298 static void create_base_index(const struct commit
*current_head
)
301 struct unpack_trees_options opts
;
309 memset(&opts
, 0, sizeof(opts
));
313 opts
.src_index
= &the_index
;
314 opts
.dst_index
= &the_index
;
316 opts
.fn
= oneway_merge
;
317 tree
= parse_tree_indirect(current_head
->object
.sha1
);
319 die(_("failed to unpack HEAD tree object"));
321 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
322 if (unpack_trees(1, &t
, &opts
))
323 exit(128); /* We've already reported the error, finish dying */
326 static void refresh_cache_or_die(int refresh_flags
)
329 * refresh_flags contains REFRESH_QUIET, so the only errors
330 * are for unmerged entries.
332 if (refresh_cache(refresh_flags
| REFRESH_IN_PORCELAIN
))
333 die_resolve_conflict("commit");
336 static char *prepare_index(int argc
, const char **argv
, const char *prefix
,
337 const struct commit
*current_head
, int is_status
)
340 struct string_list partial
;
341 const char **pathspec
= NULL
;
342 char *old_index_env
= NULL
;
343 int refresh_flags
= REFRESH_QUIET
;
346 refresh_flags
|= REFRESH_UNMERGED
;
349 pathspec
= get_pathspec(prefix
, argv
);
351 if (read_cache_preload(pathspec
) < 0)
352 die(_("index file corrupt"));
355 fd
= hold_locked_index(&index_lock
, 1);
357 refresh_cache_or_die(refresh_flags
);
359 if (write_cache(fd
, active_cache
, active_nr
) ||
360 close_lock_file(&index_lock
))
361 die(_("unable to create temporary index"));
363 old_index_env
= getenv(INDEX_ENVIRONMENT
);
364 setenv(INDEX_ENVIRONMENT
, index_lock
.filename
, 1);
366 if (interactive_add(argc
, argv
, prefix
, patch_interactive
) != 0)
367 die(_("interactive add failed"));
369 if (old_index_env
&& *old_index_env
)
370 setenv(INDEX_ENVIRONMENT
, old_index_env
, 1);
372 unsetenv(INDEX_ENVIRONMENT
);
375 read_cache_from(index_lock
.filename
);
377 commit_style
= COMMIT_NORMAL
;
378 return index_lock
.filename
;
382 * Non partial, non as-is commit.
384 * (1) get the real index;
385 * (2) update the_index as necessary;
386 * (3) write the_index out to the real index (still locked);
387 * (4) return the name of the locked index file.
389 * The caller should run hooks on the locked real index, and
390 * (A) if all goes well, commit the real index;
391 * (B) on failure, rollback the real index.
393 if (all
|| (also
&& pathspec
&& *pathspec
)) {
394 fd
= hold_locked_index(&index_lock
, 1);
395 add_files_to_cache(also
? prefix
: NULL
, pathspec
, 0);
396 refresh_cache_or_die(refresh_flags
);
397 update_main_cache_tree(1);
398 if (write_cache(fd
, active_cache
, active_nr
) ||
399 close_lock_file(&index_lock
))
400 die(_("unable to write new_index file"));
401 commit_style
= COMMIT_NORMAL
;
402 return index_lock
.filename
;
408 * (1) return the name of the real index file.
410 * The caller should run hooks on the real index,
411 * and create commit from the_index.
412 * We still need to refresh the index here.
414 if (!pathspec
|| !*pathspec
) {
415 fd
= hold_locked_index(&index_lock
, 1);
416 refresh_cache_or_die(refresh_flags
);
417 if (active_cache_changed
) {
418 update_main_cache_tree(1);
419 if (write_cache(fd
, active_cache
, active_nr
) ||
420 commit_locked_index(&index_lock
))
421 die(_("unable to write new_index file"));
423 rollback_lock_file(&index_lock
);
425 commit_style
= COMMIT_AS_IS
;
426 return get_index_file();
432 * (0) find the set of affected paths;
433 * (1) get lock on the real index file;
434 * (2) update the_index with the given paths;
435 * (3) write the_index out to the real index (still locked);
436 * (4) get lock on the false index file;
437 * (5) reset the_index from HEAD;
438 * (6) update the_index the same way as (2);
439 * (7) write the_index out to the false index file;
440 * (8) return the name of the false index file (still locked);
442 * The caller should run hooks on the locked false index, and
443 * create commit from it. Then
444 * (A) if all goes well, commit the real index;
445 * (B) on failure, rollback the real index;
446 * In either case, rollback the false index.
448 commit_style
= COMMIT_PARTIAL
;
450 if (whence
!= FROM_COMMIT
)
451 die(_("cannot do a partial commit during a %s."), whence_s());
453 memset(&partial
, 0, sizeof(partial
));
454 partial
.strdup_strings
= 1;
455 if (list_paths(&partial
, !current_head
? NULL
: "HEAD", prefix
, pathspec
))
459 if (read_cache() < 0)
460 die(_("cannot read the index"));
462 fd
= hold_locked_index(&index_lock
, 1);
463 add_remove_files(&partial
);
464 refresh_cache(REFRESH_QUIET
);
465 if (write_cache(fd
, active_cache
, active_nr
) ||
466 close_lock_file(&index_lock
))
467 die(_("unable to write new_index file"));
469 fd
= hold_lock_file_for_update(&false_lock
,
470 git_path("next-index-%"PRIuMAX
,
471 (uintmax_t) getpid()),
474 create_base_index(current_head
);
475 add_remove_files(&partial
);
476 refresh_cache(REFRESH_QUIET
);
478 if (write_cache(fd
, active_cache
, active_nr
) ||
479 close_lock_file(&false_lock
))
480 die(_("unable to write temporary index file"));
483 read_cache_from(false_lock
.filename
);
485 return false_lock
.filename
;
488 static int run_status(FILE *fp
, const char *index_file
, const char *prefix
, int nowarn
,
491 unsigned char sha1
[20];
493 if (s
->relative_paths
)
498 s
->reference
= "HEAD^1";
500 s
->verbose
= verbose
;
501 s
->index_file
= index_file
;
504 s
->is_initial
= get_sha1(s
->reference
, sha1
) ? 1 : 0;
506 wt_status_collect(s
);
508 switch (status_format
) {
509 case STATUS_FORMAT_SHORT
:
510 wt_shortstatus_print(s
, null_termination
, status_show_branch
);
512 case STATUS_FORMAT_PORCELAIN
:
513 wt_porcelain_print(s
, null_termination
);
515 case STATUS_FORMAT_LONG
:
520 return s
->commitable
;
523 static int is_a_merge(const struct commit
*current_head
)
525 return !!(current_head
->parents
&& current_head
->parents
->next
);
528 static const char sign_off_header
[] = "Signed-off-by: ";
530 static void determine_author_info(struct strbuf
*author_ident
)
532 char *name
, *email
, *date
;
534 name
= getenv("GIT_AUTHOR_NAME");
535 email
= getenv("GIT_AUTHOR_EMAIL");
536 date
= getenv("GIT_AUTHOR_DATE");
538 if (author_message
) {
539 const char *a
, *lb
, *rb
, *eol
;
541 a
= strstr(author_message_buffer
, "\nauthor ");
543 die(_("invalid commit: %s"), author_message
);
545 lb
= strchrnul(a
+ strlen("\nauthor "), '<');
546 rb
= strchrnul(lb
, '>');
547 eol
= strchrnul(rb
, '\n');
548 if (!*lb
|| !*rb
|| !*eol
)
549 die(_("invalid commit: %s"), author_message
);
551 if (lb
== a
+ strlen("\nauthor "))
552 /* \nauthor <foo@example.com> */
553 name
= xcalloc(1, 1);
555 name
= xmemdupz(a
+ strlen("\nauthor "),
557 (a
+ strlen("\nauthor "))));
558 email
= xmemdupz(lb
+ strlen("<"), rb
- (lb
+ strlen("<")));
559 date
= xmemdupz(rb
+ strlen("> "), eol
- (rb
+ strlen("> ")));
563 const char *lb
= strstr(force_author
, " <");
564 const char *rb
= strchr(force_author
, '>');
567 die(_("malformed --author parameter"));
568 name
= xstrndup(force_author
, lb
- force_author
);
569 email
= xstrndup(lb
+ 2, rb
- (lb
+ 2));
574 strbuf_addstr(author_ident
, fmt_ident(name
, email
, date
,
575 IDENT_ERROR_ON_NO_NAME
));
578 static int ends_rfc2822_footer(struct strbuf
*sb
)
585 const char *buf
= sb
->buf
;
587 for (i
= len
- 1; i
> 0; i
--) {
588 if (hit
&& buf
[i
] == '\n')
590 hit
= (buf
[i
] == '\n');
593 while (i
< len
- 1 && buf
[i
] == '\n')
596 for (; i
< len
; i
= k
) {
597 for (k
= i
; k
< len
&& buf
[k
] != '\n'; k
++)
601 if ((buf
[k
] == ' ' || buf
[k
] == '\t') && !first
)
606 for (j
= 0; i
+ j
< len
; j
++) {
619 static char *cut_ident_timestamp_part(char *string
)
621 char *ket
= strrchr(string
, '>');
622 if (!ket
|| ket
[1] != ' ')
623 die(_("Malformed ident string: '%s'"), string
);
628 static int prepare_to_commit(const char *index_file
, const char *prefix
,
629 struct commit
*current_head
,
631 struct strbuf
*author_ident
)
634 struct strbuf committer_ident
= STRBUF_INIT
;
635 int commitable
, saved_color_setting
;
636 struct strbuf sb
= STRBUF_INIT
;
638 const char *hook_arg1
= NULL
;
639 const char *hook_arg2
= NULL
;
641 int clean_message_contents
= (cleanup_mode
!= CLEANUP_NONE
);
643 if (!no_verify
&& run_hook(index_file
, "pre-commit", NULL
))
646 if (squash_message
) {
648 * Insert the proper subject line before other commit
649 * message options add their content.
651 if (use_message
&& !strcmp(use_message
, squash_message
))
652 strbuf_addstr(&sb
, "squash! ");
654 struct pretty_print_context ctx
= {0};
656 c
= lookup_commit_reference_by_name(squash_message
);
658 die(_("could not lookup commit %s"), squash_message
);
659 ctx
.output_encoding
= get_commit_output_encoding();
660 format_commit_message(c
, "squash! %s\n\n", &sb
,
666 strbuf_addbuf(&sb
, &message
);
667 hook_arg1
= "message";
668 } else if (logfile
&& !strcmp(logfile
, "-")) {
670 fprintf(stderr
, _("(reading log message from standard input)\n"));
671 if (strbuf_read(&sb
, 0, 0) < 0)
672 die_errno(_("could not read log from standard input"));
673 hook_arg1
= "message";
674 } else if (logfile
) {
675 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
676 die_errno(_("could not read log file '%s'"),
678 hook_arg1
= "message";
679 } else if (use_message
) {
680 buffer
= strstr(use_message_buffer
, "\n\n");
681 if (!buffer
|| buffer
[2] == '\0')
682 die(_("commit has empty message"));
683 strbuf_add(&sb
, buffer
+ 2, strlen(buffer
+ 2));
684 hook_arg1
= "commit";
685 hook_arg2
= use_message
;
686 } else if (fixup_message
) {
687 struct pretty_print_context ctx
= {0};
688 struct commit
*commit
;
689 commit
= lookup_commit_reference_by_name(fixup_message
);
691 die(_("could not lookup commit %s"), fixup_message
);
692 ctx
.output_encoding
= get_commit_output_encoding();
693 format_commit_message(commit
, "fixup! %s\n\n",
695 hook_arg1
= "message";
696 } else if (!stat(git_path("MERGE_MSG"), &statbuf
)) {
697 if (strbuf_read_file(&sb
, git_path("MERGE_MSG"), 0) < 0)
698 die_errno(_("could not read MERGE_MSG"));
700 } else if (!stat(git_path("SQUASH_MSG"), &statbuf
)) {
701 if (strbuf_read_file(&sb
, git_path("SQUASH_MSG"), 0) < 0)
702 die_errno(_("could not read SQUASH_MSG"));
703 hook_arg1
= "squash";
704 } else if (template_file
) {
705 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
706 die_errno(_("could not read '%s'"), template_file
);
707 hook_arg1
= "template";
708 clean_message_contents
= 0;
712 * The remaining cases don't modify the template message, but
713 * just set the argument(s) to the prepare-commit-msg hook.
715 else if (whence
== FROM_MERGE
)
717 else if (whence
== FROM_CHERRY_PICK
) {
718 hook_arg1
= "commit";
719 hook_arg2
= "CHERRY_PICK_HEAD";
722 if (squash_message
) {
724 * If squash_commit was used for the commit subject,
725 * then we're possibly hijacking other commit log options.
726 * Reset the hook args to tell the real story.
728 hook_arg1
= "message";
732 s
->fp
= fopen(git_path(commit_editmsg
), "w");
734 die_errno(_("could not open '%s'"), git_path(commit_editmsg
));
736 if (clean_message_contents
)
740 struct strbuf sob
= STRBUF_INIT
;
743 strbuf_addstr(&sob
, sign_off_header
);
744 strbuf_addstr(&sob
, fmt_name(getenv("GIT_COMMITTER_NAME"),
745 getenv("GIT_COMMITTER_EMAIL")));
746 strbuf_addch(&sob
, '\n');
747 for (i
= sb
.len
- 1; i
> 0 && sb
.buf
[i
- 1] != '\n'; i
--)
749 if (prefixcmp(sb
.buf
+ i
, sob
.buf
)) {
750 if (!i
|| !ends_rfc2822_footer(&sb
))
751 strbuf_addch(&sb
, '\n');
752 strbuf_addbuf(&sb
, &sob
);
754 strbuf_release(&sob
);
757 if (fwrite(sb
.buf
, 1, sb
.len
, s
->fp
) < sb
.len
)
758 die_errno(_("could not write commit template"));
762 /* This checks and barfs if author is badly specified */
763 determine_author_info(author_ident
);
765 /* This checks if committer ident is explicitly given */
766 strbuf_addstr(&committer_ident
, git_committer_info(0));
767 if (use_editor
&& include_status
) {
768 char *ai_tmp
, *ci_tmp
;
769 if (whence
!= FROM_COMMIT
)
770 status_printf_ln(s
, GIT_COLOR_NORMAL
,
772 "It looks like you may be committing a %s.\n"
773 "If this is not correct, please remove the file\n"
778 git_path(whence
== FROM_MERGE
780 : "CHERRY_PICK_HEAD"));
782 fprintf(s
->fp
, "\n");
783 status_printf(s
, GIT_COLOR_NORMAL
,
784 _("Please enter the commit message for your changes."));
785 if (cleanup_mode
== CLEANUP_ALL
)
786 status_printf_more(s
, GIT_COLOR_NORMAL
,
787 _(" Lines starting\n"
788 "with '#' will be ignored, and an empty"
789 " message aborts the commit.\n"));
790 else /* CLEANUP_SPACE, that is. */
791 status_printf_more(s
, GIT_COLOR_NORMAL
,
792 _(" Lines starting\n"
793 "with '#' will be kept; you may remove them"
794 " yourself if you want to.\n"
795 "An empty message aborts the commit.\n"));
796 if (only_include_assumed
)
797 status_printf_ln(s
, GIT_COLOR_NORMAL
,
798 "%s", only_include_assumed
);
800 ai_tmp
= cut_ident_timestamp_part(author_ident
->buf
);
801 ci_tmp
= cut_ident_timestamp_part(committer_ident
.buf
);
802 if (strcmp(author_ident
->buf
, committer_ident
.buf
))
803 status_printf_ln(s
, GIT_COLOR_NORMAL
,
806 ident_shown
++ ? "" : "\n",
809 if (!user_ident_sufficiently_given())
810 status_printf_ln(s
, GIT_COLOR_NORMAL
,
813 ident_shown
++ ? "" : "\n",
814 committer_ident
.buf
);
817 status_printf_ln(s
, GIT_COLOR_NORMAL
, "");
819 saved_color_setting
= s
->use_color
;
821 commitable
= run_status(s
->fp
, index_file
, prefix
, 1, s
);
822 s
->use_color
= saved_color_setting
;
827 unsigned char sha1
[20];
828 const char *parent
= "HEAD";
830 if (!active_nr
&& read_cache() < 0)
831 die(_("Cannot read index"));
836 if (get_sha1(parent
, sha1
))
837 commitable
= !!active_nr
;
839 commitable
= index_differs_from(parent
, 0);
841 strbuf_release(&committer_ident
);
846 * Reject an attempt to record a non-merge empty commit without
847 * explicit --allow-empty. In the cherry-pick case, it may be
848 * empty due to conflict resolution, which the user should okay.
850 if (!commitable
&& whence
!= FROM_MERGE
&& !allow_empty
&&
851 !(amend
&& is_a_merge(current_head
))) {
852 run_status(stdout
, index_file
, prefix
, 0, s
);
854 fputs(_(empty_amend_advice
), stderr
);
855 else if (whence
== FROM_CHERRY_PICK
)
856 fputs(_(empty_cherry_pick_advice
), stderr
);
861 * Re-read the index as pre-commit hook could have updated it,
862 * and write it out as a tree. We must do this before we invoke
863 * the editor and after we invoke run_status above.
866 read_cache_from(index_file
);
867 if (update_main_cache_tree(0)) {
868 error(_("Error building trees"));
872 if (run_hook(index_file
, "prepare-commit-msg",
873 git_path(commit_editmsg
), hook_arg1
, hook_arg2
, NULL
))
877 char index
[PATH_MAX
];
878 const char *env
[2] = { NULL
};
880 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
881 if (launch_editor(git_path(commit_editmsg
), NULL
, env
)) {
883 _("Please supply the message using either -m or -F option.\n"));
889 run_hook(index_file
, "commit-msg", git_path(commit_editmsg
), NULL
)) {
897 * Find out if the message in the strbuf contains only whitespace and
898 * Signed-off-by lines.
900 static int message_is_empty(struct strbuf
*sb
)
902 struct strbuf tmpl
= STRBUF_INIT
;
904 int eol
, i
, start
= 0;
906 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
909 /* See if the template is just a prefix of the message. */
910 if (template_file
&& strbuf_read_file(&tmpl
, template_file
, 0) > 0) {
911 stripspace(&tmpl
, cleanup_mode
== CLEANUP_ALL
);
912 if (start
+ tmpl
.len
<= sb
->len
&&
913 memcmp(tmpl
.buf
, sb
->buf
+ start
, tmpl
.len
) == 0)
916 strbuf_release(&tmpl
);
918 /* Check if the rest is just whitespace and Signed-of-by's. */
919 for (i
= start
; i
< sb
->len
; i
++) {
920 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
926 if (strlen(sign_off_header
) <= eol
- i
&&
927 !prefixcmp(sb
->buf
+ i
, sign_off_header
)) {
932 if (!isspace(sb
->buf
[i
++]))
939 static const char *find_author_by_nickname(const char *name
)
941 struct rev_info revs
;
942 struct commit
*commit
;
943 struct strbuf buf
= STRBUF_INIT
;
947 init_revisions(&revs
, NULL
);
948 strbuf_addf(&buf
, "--author=%s", name
);
953 setup_revisions(ac
, av
, &revs
, NULL
);
954 prepare_revision_walk(&revs
);
955 commit
= get_revision(&revs
);
957 struct pretty_print_context ctx
= {0};
958 ctx
.date_mode
= DATE_NORMAL
;
959 strbuf_release(&buf
);
960 format_commit_message(commit
, "%an <%ae>", &buf
, &ctx
);
961 return strbuf_detach(&buf
, NULL
);
963 die(_("No existing author found with '%s'"), name
);
967 static void handle_untracked_files_arg(struct wt_status
*s
)
969 if (!untracked_files_arg
)
970 ; /* default already initialized */
971 else if (!strcmp(untracked_files_arg
, "no"))
972 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
973 else if (!strcmp(untracked_files_arg
, "normal"))
974 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
975 else if (!strcmp(untracked_files_arg
, "all"))
976 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
978 die(_("Invalid untracked files mode '%s'"), untracked_files_arg
);
981 static const char *read_commit_message(const char *name
)
983 const char *out_enc
, *out
;
984 struct commit
*commit
;
986 commit
= lookup_commit_reference_by_name(name
);
988 die(_("could not lookup commit %s"), name
);
989 out_enc
= get_commit_output_encoding();
990 out
= logmsg_reencode(commit
, out_enc
);
993 * If we failed to reencode the buffer, just copy it
994 * byte for byte so the user can try to fix it up.
995 * This also handles the case where input and output
996 * encodings are identical.
999 out
= xstrdup(commit
->buffer
);
1003 static int parse_and_validate_options(int argc
, const char *argv
[],
1004 const char * const usage
[],
1006 struct commit
*current_head
,
1007 struct wt_status
*s
)
1011 argc
= parse_options(argc
, argv
, prefix
, builtin_commit_options
, usage
,
1014 if (force_author
&& !strchr(force_author
, '>'))
1015 force_author
= find_author_by_nickname(force_author
);
1017 if (force_author
&& renew_authorship
)
1018 die(_("Using both --reset-author and --author does not make sense"));
1020 if (logfile
|| message
.len
|| use_message
|| fixup_message
)
1025 setenv("GIT_EDITOR", ":", 1);
1027 /* Sanity check options */
1028 if (amend
&& !current_head
)
1029 die(_("You have nothing to amend."));
1030 if (amend
&& whence
!= FROM_COMMIT
)
1031 die(_("You are in the middle of a %s -- cannot amend."), whence_s());
1032 if (fixup_message
&& squash_message
)
1033 die(_("Options --squash and --fixup cannot be used together"));
1043 die(_("Only one of -c/-C/-F/--fixup can be used."));
1044 if (message
.len
&& f
> 0)
1045 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1047 use_message
= edit_message
;
1048 if (amend
&& !use_message
&& !fixup_message
)
1049 use_message
= "HEAD";
1050 if (!use_message
&& whence
!= FROM_CHERRY_PICK
&& renew_authorship
)
1051 die(_("--reset-author can be used only with -C, -c or --amend."));
1053 use_message_buffer
= read_commit_message(use_message
);
1054 if (!renew_authorship
) {
1055 author_message
= use_message
;
1056 author_message_buffer
= use_message_buffer
;
1059 if (whence
== FROM_CHERRY_PICK
&& !renew_authorship
) {
1060 author_message
= "CHERRY_PICK_HEAD";
1061 author_message_buffer
= read_commit_message(author_message
);
1064 if (patch_interactive
)
1067 if (!!also
+ !!only
+ !!all
+ !!interactive
> 1)
1068 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1069 if (argc
== 0 && (also
|| (only
&& !amend
)))
1070 die(_("No paths with --include/--only does not make sense."));
1071 if (argc
== 0 && only
&& amend
)
1072 only_include_assumed
= _("Clever... amending the last one with dirty index.");
1073 if (argc
> 0 && !also
&& !only
)
1074 only_include_assumed
= _("Explicit paths specified without -i nor -o; assuming --only paths...");
1075 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
1076 cleanup_mode
= use_editor
? CLEANUP_ALL
: CLEANUP_SPACE
;
1077 else if (!strcmp(cleanup_arg
, "verbatim"))
1078 cleanup_mode
= CLEANUP_NONE
;
1079 else if (!strcmp(cleanup_arg
, "whitespace"))
1080 cleanup_mode
= CLEANUP_SPACE
;
1081 else if (!strcmp(cleanup_arg
, "strip"))
1082 cleanup_mode
= CLEANUP_ALL
;
1084 die(_("Invalid cleanup mode %s"), cleanup_arg
);
1086 handle_untracked_files_arg(s
);
1088 if (all
&& argc
> 0)
1089 die(_("Paths with -a does not make sense."));
1091 if (null_termination
&& status_format
== STATUS_FORMAT_LONG
)
1092 status_format
= STATUS_FORMAT_PORCELAIN
;
1093 if (status_format
!= STATUS_FORMAT_LONG
)
1099 static int dry_run_commit(int argc
, const char **argv
, const char *prefix
,
1100 const struct commit
*current_head
, struct wt_status
*s
)
1103 const char *index_file
;
1105 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 1);
1106 commitable
= run_status(stdout
, index_file
, prefix
, 0, s
);
1107 rollback_index_files();
1109 return commitable
? 0 : 1;
1112 static int parse_status_slot(const char *var
, int offset
)
1114 if (!strcasecmp(var
+offset
, "header"))
1115 return WT_STATUS_HEADER
;
1116 if (!strcasecmp(var
+offset
, "branch"))
1117 return WT_STATUS_ONBRANCH
;
1118 if (!strcasecmp(var
+offset
, "updated")
1119 || !strcasecmp(var
+offset
, "added"))
1120 return WT_STATUS_UPDATED
;
1121 if (!strcasecmp(var
+offset
, "changed"))
1122 return WT_STATUS_CHANGED
;
1123 if (!strcasecmp(var
+offset
, "untracked"))
1124 return WT_STATUS_UNTRACKED
;
1125 if (!strcasecmp(var
+offset
, "nobranch"))
1126 return WT_STATUS_NOBRANCH
;
1127 if (!strcasecmp(var
+offset
, "unmerged"))
1128 return WT_STATUS_UNMERGED
;
1132 static int git_status_config(const char *k
, const char *v
, void *cb
)
1134 struct wt_status
*s
= cb
;
1136 if (!strcmp(k
, "status.submodulesummary")) {
1138 s
->submodule_summary
= git_config_bool_or_int(k
, v
, &is_bool
);
1139 if (is_bool
&& s
->submodule_summary
)
1140 s
->submodule_summary
= -1;
1143 if (!strcmp(k
, "status.color") || !strcmp(k
, "color.status")) {
1144 s
->use_color
= git_config_colorbool(k
, v
);
1147 if (!prefixcmp(k
, "status.color.") || !prefixcmp(k
, "color.status.")) {
1148 int slot
= parse_status_slot(k
, 13);
1152 return config_error_nonbool(k
);
1153 color_parse(v
, k
, s
->color_palette
[slot
]);
1156 if (!strcmp(k
, "status.relativepaths")) {
1157 s
->relative_paths
= git_config_bool(k
, v
);
1160 if (!strcmp(k
, "status.showuntrackedfiles")) {
1162 return config_error_nonbool(k
);
1163 else if (!strcmp(v
, "no"))
1164 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1165 else if (!strcmp(v
, "normal"))
1166 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1167 else if (!strcmp(v
, "all"))
1168 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1170 return error(_("Invalid untracked files mode '%s'"), v
);
1173 return git_diff_ui_config(k
, v
, NULL
);
1176 int cmd_status(int argc
, const char **argv
, const char *prefix
)
1180 unsigned char sha1
[20];
1181 static struct option builtin_status_options
[] = {
1182 OPT__VERBOSE(&verbose
, "be verbose"),
1183 OPT_SET_INT('s', "short", &status_format
,
1184 "show status concisely", STATUS_FORMAT_SHORT
),
1185 OPT_BOOLEAN('b', "branch", &status_show_branch
,
1186 "show branch information"),
1187 OPT_SET_INT(0, "porcelain", &status_format
,
1188 "machine-readable output",
1189 STATUS_FORMAT_PORCELAIN
),
1190 OPT_BOOLEAN('z', "null", &null_termination
,
1191 "terminate entries with NUL"),
1192 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
,
1194 "show untracked files, optional modes: all, normal, no. (Default: all)",
1195 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1196 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status
,
1197 "show ignored files"),
1198 { OPTION_STRING
, 0, "ignore-submodules", &ignore_submodule_arg
, "when",
1199 "ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)",
1200 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1204 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1205 usage_with_options(builtin_status_usage
, builtin_status_options
);
1207 wt_status_prepare(&s
);
1208 gitmodules_config();
1209 git_config(git_status_config
, &s
);
1210 determine_whence(&s
);
1211 argc
= parse_options(argc
, argv
, prefix
,
1212 builtin_status_options
,
1213 builtin_status_usage
, 0);
1215 if (null_termination
&& status_format
== STATUS_FORMAT_LONG
)
1216 status_format
= STATUS_FORMAT_PORCELAIN
;
1218 handle_untracked_files_arg(&s
);
1219 if (show_ignored_in_status
)
1220 s
.show_ignored_files
= 1;
1222 s
.pathspec
= get_pathspec(prefix
, argv
);
1224 read_cache_preload(s
.pathspec
);
1225 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, s
.pathspec
, NULL
, NULL
);
1227 fd
= hold_locked_index(&index_lock
, 0);
1229 update_index_if_able(&the_index
, &index_lock
);
1231 s
.is_initial
= get_sha1(s
.reference
, sha1
) ? 1 : 0;
1232 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1233 wt_status_collect(&s
);
1235 if (s
.relative_paths
)
1238 switch (status_format
) {
1239 case STATUS_FORMAT_SHORT
:
1240 wt_shortstatus_print(&s
, null_termination
, status_show_branch
);
1242 case STATUS_FORMAT_PORCELAIN
:
1243 wt_porcelain_print(&s
, null_termination
);
1245 case STATUS_FORMAT_LONG
:
1246 s
.verbose
= verbose
;
1247 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1248 wt_status_print(&s
);
1254 static void print_summary(const char *prefix
, const unsigned char *sha1
,
1257 struct rev_info rev
;
1258 struct commit
*commit
;
1259 struct strbuf format
= STRBUF_INIT
;
1260 unsigned char junk_sha1
[20];
1261 const char *head
= resolve_ref("HEAD", junk_sha1
, 0, NULL
);
1262 struct pretty_print_context pctx
= {0};
1263 struct strbuf author_ident
= STRBUF_INIT
;
1264 struct strbuf committer_ident
= STRBUF_INIT
;
1266 commit
= lookup_commit(sha1
);
1268 die(_("couldn't look up newly created commit"));
1269 if (!commit
|| parse_commit(commit
))
1270 die(_("could not parse newly created commit"));
1272 strbuf_addstr(&format
, "format:%h] %s");
1274 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1275 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1276 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1277 strbuf_addstr(&format
, "\n Author: ");
1278 strbuf_addbuf_percentquote(&format
, &author_ident
);
1280 if (!user_ident_sufficiently_given()) {
1281 strbuf_addstr(&format
, "\n Committer: ");
1282 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1283 if (advice_implicit_identity
) {
1284 strbuf_addch(&format
, '\n');
1285 strbuf_addstr(&format
, _(implicit_ident_advice
));
1288 strbuf_release(&author_ident
);
1289 strbuf_release(&committer_ident
);
1291 init_revisions(&rev
, prefix
);
1292 setup_revisions(0, NULL
, &rev
, NULL
);
1295 rev
.diffopt
.output_format
=
1296 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1298 rev
.verbose_header
= 1;
1299 rev
.show_root_diff
= 1;
1300 get_commit_format(format
.buf
, &rev
);
1301 rev
.always_show_header
= 0;
1302 rev
.diffopt
.detect_rename
= 1;
1303 rev
.diffopt
.break_opt
= 0;
1304 diff_setup_done(&rev
.diffopt
);
1307 !prefixcmp(head
, "refs/heads/") ?
1309 !strcmp(head
, "HEAD") ?
1310 _("detached HEAD") :
1312 initial_commit
? _(" (root-commit)") : "");
1314 if (!log_tree_commit(&rev
, commit
)) {
1315 rev
.always_show_header
= 1;
1316 rev
.use_terminator
= 1;
1317 log_tree_commit(&rev
, commit
);
1320 strbuf_release(&format
);
1323 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1325 struct wt_status
*s
= cb
;
1327 if (!strcmp(k
, "commit.template"))
1328 return git_config_pathname(&template_file
, k
, v
);
1329 if (!strcmp(k
, "commit.status")) {
1330 include_status
= git_config_bool(k
, v
);
1334 return git_status_config(k
, v
, s
);
1337 static const char post_rewrite_hook
[] = "hooks/post-rewrite";
1339 static int run_rewrite_hook(const unsigned char *oldsha1
,
1340 const unsigned char *newsha1
)
1342 /* oldsha1 SP newsha1 LF NUL */
1343 static char buf
[2*40 + 3];
1344 struct child_process proc
;
1345 const char *argv
[3];
1349 if (access(git_path(post_rewrite_hook
), X_OK
) < 0)
1352 argv
[0] = git_path(post_rewrite_hook
);
1356 memset(&proc
, 0, sizeof(proc
));
1359 proc
.stdout_to_stderr
= 1;
1361 code
= start_command(&proc
);
1364 n
= snprintf(buf
, sizeof(buf
), "%s %s\n",
1365 sha1_to_hex(oldsha1
), sha1_to_hex(newsha1
));
1366 write_in_full(proc
.in
, buf
, n
);
1368 return finish_command(&proc
);
1371 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1373 struct strbuf sb
= STRBUF_INIT
;
1374 struct strbuf author_ident
= STRBUF_INIT
;
1375 const char *index_file
, *reflog_msg
;
1377 unsigned char sha1
[20];
1378 struct ref_lock
*ref_lock
;
1379 struct commit_list
*parents
= NULL
, **pptr
= &parents
;
1380 struct stat statbuf
;
1381 int allow_fast_forward
= 1;
1383 struct commit
*current_head
= NULL
;
1385 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1386 usage_with_options(builtin_commit_usage
, builtin_commit_options
);
1388 wt_status_prepare(&s
);
1389 git_config(git_commit_config
, &s
);
1390 determine_whence(&s
);
1392 if (get_sha1("HEAD", sha1
))
1393 current_head
= NULL
;
1395 current_head
= lookup_commit_or_die(sha1
, "HEAD");
1396 if (!current_head
|| parse_commit(current_head
))
1397 die(_("could not parse HEAD commit"));
1399 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_usage
,
1400 prefix
, current_head
, &s
);
1402 return dry_run_commit(argc
, argv
, prefix
, current_head
, &s
);
1403 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 0);
1405 /* Set up everything for writing the commit object. This includes
1406 running hooks, writing the trees, and interacting with the user. */
1407 if (!prepare_to_commit(index_file
, prefix
,
1408 current_head
, &s
, &author_ident
)) {
1409 rollback_index_files();
1413 /* Determine parents */
1414 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1415 if (!current_head
) {
1417 reflog_msg
= "commit (initial)";
1419 struct commit_list
*c
;
1422 reflog_msg
= "commit (amend)";
1423 for (c
= current_head
->parents
; c
; c
= c
->next
)
1424 pptr
= &commit_list_insert(c
->item
, pptr
)->next
;
1425 } else if (whence
== FROM_MERGE
) {
1426 struct strbuf m
= STRBUF_INIT
;
1427 struct commit
*commit
;
1431 reflog_msg
= "commit (merge)";
1432 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1433 fp
= fopen(git_path("MERGE_HEAD"), "r");
1435 die_errno(_("could not open '%s' for reading"),
1436 git_path("MERGE_HEAD"));
1437 while (strbuf_getline(&m
, fp
, '\n') != EOF
) {
1438 unsigned char sha1
[20];
1439 if (get_sha1_hex(m
.buf
, sha1
) < 0)
1440 die(_("Corrupt MERGE_HEAD file (%s)"), m
.buf
);
1441 commit
= lookup_commit_or_die(sha1
, "MERGE_HEAD");
1442 pptr
= &commit_list_insert(commit
, pptr
)->next
;
1446 if (!stat(git_path("MERGE_MODE"), &statbuf
)) {
1447 if (strbuf_read_file(&sb
, git_path("MERGE_MODE"), 0) < 0)
1448 die_errno(_("could not read MERGE_MODE"));
1449 if (!strcmp(sb
.buf
, "no-ff"))
1450 allow_fast_forward
= 0;
1452 if (allow_fast_forward
)
1453 parents
= reduce_heads(parents
);
1456 reflog_msg
= (whence
== FROM_CHERRY_PICK
)
1457 ? "commit (cherry-pick)"
1459 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1462 /* Finally, get the commit message */
1464 if (strbuf_read_file(&sb
, git_path(commit_editmsg
), 0) < 0) {
1465 int saved_errno
= errno
;
1466 rollback_index_files();
1467 die(_("could not read commit message: %s"), strerror(saved_errno
));
1470 /* Truncate the message just before the diff, if any. */
1472 p
= strstr(sb
.buf
, "\ndiff --git ");
1474 strbuf_setlen(&sb
, p
- sb
.buf
+ 1);
1477 if (cleanup_mode
!= CLEANUP_NONE
)
1478 stripspace(&sb
, cleanup_mode
== CLEANUP_ALL
);
1479 if (message_is_empty(&sb
) && !allow_empty_message
) {
1480 rollback_index_files();
1481 fprintf(stderr
, _("Aborting commit due to empty commit message.\n"));
1485 if (commit_tree(sb
.buf
, active_cache_tree
->sha1
, parents
, sha1
,
1486 author_ident
.buf
)) {
1487 rollback_index_files();
1488 die(_("failed to write commit object"));
1490 strbuf_release(&author_ident
);
1492 ref_lock
= lock_any_ref_for_update("HEAD",
1495 : current_head
->object
.sha1
,
1498 nl
= strchr(sb
.buf
, '\n');
1500 strbuf_setlen(&sb
, nl
+ 1 - sb
.buf
);
1502 strbuf_addch(&sb
, '\n');
1503 strbuf_insert(&sb
, 0, reflog_msg
, strlen(reflog_msg
));
1504 strbuf_insert(&sb
, strlen(reflog_msg
), ": ", 2);
1507 rollback_index_files();
1508 die(_("cannot lock HEAD ref"));
1510 if (write_ref_sha1(ref_lock
, sha1
, sb
.buf
) < 0) {
1511 rollback_index_files();
1512 die(_("cannot update HEAD ref"));
1515 unlink(git_path("CHERRY_PICK_HEAD"));
1516 unlink(git_path("REVERT_HEAD"));
1517 unlink(git_path("MERGE_HEAD"));
1518 unlink(git_path("MERGE_MSG"));
1519 unlink(git_path("MERGE_MODE"));
1520 unlink(git_path("SQUASH_MSG"));
1522 if (commit_index_files())
1523 die (_("Repository has been updated, but unable to write\n"
1524 "new_index file. Check that disk is not full or quota is\n"
1525 "not exceeded, and then \"git reset HEAD\" to recover."));
1528 run_hook(get_index_file(), "post-commit", NULL
);
1529 if (amend
&& !no_post_rewrite
) {
1530 struct notes_rewrite_cfg
*cfg
;
1531 cfg
= init_copy_notes_for_rewrite("amend");
1533 /* we are amending, so current_head is not NULL */
1534 copy_note_for_rewrite(cfg
, current_head
->object
.sha1
, sha1
);
1535 finish_copy_notes_for_rewrite(cfg
);
1537 run_rewrite_hook(current_head
->object
.sha1
, sha1
);
1540 print_summary(prefix
, sha1
, !current_head
);