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"
29 #include "gpg-interface.h"
31 static const char * const builtin_commit_usage
[] = {
32 "git commit [options] [--] <filepattern>...",
36 static const char * const builtin_status_usage
[] = {
37 "git status [options] [--] <filepattern>...",
41 static const char implicit_ident_advice
[] =
42 N_("Your name and email address were configured automatically based\n"
43 "on your username and hostname. Please check that they are accurate.\n"
44 "You can suppress this message by setting them explicitly:\n"
46 " git config --global user.name \"Your Name\"\n"
47 " git config --global user.email you@example.com\n"
49 "After doing this, you may fix the identity used for this commit with:\n"
51 " git commit --amend --reset-author\n");
53 static const char empty_amend_advice
[] =
54 N_("You asked to amend the most recent commit, but doing so would make\n"
55 "it empty. You can repeat your command with --allow-empty, or you can\n"
56 "remove the commit entirely with \"git reset HEAD^\".\n");
58 static const char empty_cherry_pick_advice
[] =
59 N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
60 "If you wish to commit it anyway, use:\n"
62 " git commit --allow-empty\n"
64 "Otherwise, please use 'git reset'\n");
66 static const char *use_message_buffer
;
67 static const char commit_editmsg
[] = "COMMIT_EDITMSG";
68 static struct lock_file index_lock
; /* real index */
69 static struct lock_file false_lock
; /* used only for partial commits */
76 static const char *logfile
, *force_author
;
77 static const char *template_file
;
79 * The _message variables are commit names from which to take
80 * the commit message and/or authorship.
82 static const char *author_message
, *author_message_buffer
;
83 static char *edit_message
, *use_message
;
84 static char *fixup_message
, *squash_message
;
85 static int all
, edit_flag
, also
, interactive
, patch_interactive
, only
, amend
, signoff
;
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
;
89 static char *sign_commit
;
92 * The default commit message cleanup mode will remove the lines
93 * beginning with # (shell comments) and leading and trailing
94 * whitespaces (empty lines or containing only whitespaces)
95 * if editor is used, and only the whitespaces if the message
96 * is specified explicitly.
103 static char *cleanup_arg
;
105 static enum commit_whence whence
;
106 static int use_editor
= 1, include_status
= 1;
107 static int show_ignored_in_status
;
108 static const char *only_include_assumed
;
109 static struct strbuf message
;
111 static int null_termination
;
115 STATUS_FORMAT_PORCELAIN
116 } status_format
= STATUS_FORMAT_LONG
;
117 static int status_show_branch
;
119 static int opt_parse_m(const struct option
*opt
, const char *arg
, int unset
)
121 struct strbuf
*buf
= opt
->value
;
123 strbuf_setlen(buf
, 0);
125 strbuf_addstr(buf
, arg
);
126 strbuf_addstr(buf
, "\n\n");
131 static struct option builtin_commit_options
[] = {
132 OPT__QUIET(&quiet
, "suppress summary after successful commit"),
133 OPT__VERBOSE(&verbose
, "show diff in commit message template"),
135 OPT_GROUP("Commit message options"),
136 OPT_FILENAME('F', "file", &logfile
, "read message from file"),
137 OPT_STRING(0, "author", &force_author
, "author", "override author for commit"),
138 OPT_STRING(0, "date", &force_date
, "date", "override date for commit"),
139 OPT_CALLBACK('m', "message", &message
, "message", "commit message", opt_parse_m
),
140 OPT_STRING('c', "reedit-message", &edit_message
, "commit", "reuse and edit message from specified commit"),
141 OPT_STRING('C', "reuse-message", &use_message
, "commit", "reuse message from specified commit"),
142 OPT_STRING(0, "fixup", &fixup_message
, "commit", "use autosquash formatted message to fixup specified commit"),
143 OPT_STRING(0, "squash", &squash_message
, "commit", "use autosquash formatted message to squash specified commit"),
144 OPT_BOOLEAN(0, "reset-author", &renew_authorship
, "the commit is authored by me now (used with -C-c/--amend)"),
145 OPT_BOOLEAN('s', "signoff", &signoff
, "add Signed-off-by:"),
146 OPT_FILENAME('t', "template", &template_file
, "use specified template file"),
147 OPT_BOOLEAN('e', "edit", &edit_flag
, "force edit of commit"),
148 OPT_STRING(0, "cleanup", &cleanup_arg
, "default", "how to strip spaces and #comments from message"),
149 OPT_BOOLEAN(0, "status", &include_status
, "include status in commit message template"),
150 { OPTION_STRING
, 'S', "gpg-sign", &sign_commit
, "key id",
151 "GPG sign commit", PARSE_OPT_OPTARG
, NULL
, (intptr_t) "" },
152 /* end commit message options */
154 OPT_GROUP("Commit contents options"),
155 OPT_BOOLEAN('a', "all", &all
, "commit all changed files"),
156 OPT_BOOLEAN('i', "include", &also
, "add specified files to index for commit"),
157 OPT_BOOLEAN(0, "interactive", &interactive
, "interactively add files"),
158 OPT_BOOLEAN('p', "patch", &patch_interactive
, "interactively add changes"),
159 OPT_BOOLEAN('o', "only", &only
, "commit only specified files"),
160 OPT_BOOLEAN('n', "no-verify", &no_verify
, "bypass pre-commit hook"),
161 OPT_BOOLEAN(0, "dry-run", &dry_run
, "show what would be committed"),
162 OPT_SET_INT(0, "short", &status_format
, "show status concisely",
163 STATUS_FORMAT_SHORT
),
164 OPT_BOOLEAN(0, "branch", &status_show_branch
, "show branch information"),
165 OPT_SET_INT(0, "porcelain", &status_format
,
166 "machine-readable output", STATUS_FORMAT_PORCELAIN
),
167 OPT_BOOLEAN('z', "null", &null_termination
,
168 "terminate entries with NUL"),
169 OPT_BOOLEAN(0, "amend", &amend
, "amend previous commit"),
170 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite
, "bypass post-rewrite hook"),
171 { 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" },
172 /* end commit contents options */
174 { OPTION_BOOLEAN
, 0, "allow-empty", &allow_empty
, NULL
,
175 "ok to record an empty change",
176 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
177 { OPTION_BOOLEAN
, 0, "allow-empty-message", &allow_empty_message
, NULL
,
178 "ok to record a change with an empty message",
179 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
184 static void determine_whence(struct wt_status
*s
)
186 if (file_exists(git_path("MERGE_HEAD")))
188 else if (file_exists(git_path("CHERRY_PICK_HEAD")))
189 whence
= FROM_CHERRY_PICK
;
191 whence
= FROM_COMMIT
;
196 static const char *whence_s(void)
206 case FROM_CHERRY_PICK
:
214 static void rollback_index_files(void)
216 switch (commit_style
) {
218 break; /* nothing to do */
220 rollback_lock_file(&index_lock
);
223 rollback_lock_file(&index_lock
);
224 rollback_lock_file(&false_lock
);
229 static int commit_index_files(void)
233 switch (commit_style
) {
235 break; /* nothing to do */
237 err
= commit_lock_file(&index_lock
);
240 err
= commit_lock_file(&index_lock
);
241 rollback_lock_file(&false_lock
);
249 * Take a union of paths in the index and the named tree (typically, "HEAD"),
250 * and return the paths that match the given pattern in list.
252 static int list_paths(struct string_list
*list
, const char *with_tree
,
253 const char *prefix
, const char **pattern
)
258 for (i
= 0; pattern
[i
]; i
++)
263 char *max_prefix
= common_prefix(pattern
);
264 overlay_tree_on_cache(with_tree
, max_prefix
? max_prefix
: prefix
);
268 for (i
= 0; i
< active_nr
; i
++) {
269 struct cache_entry
*ce
= active_cache
[i
];
270 struct string_list_item
*item
;
272 if (ce
->ce_flags
& CE_UPDATE
)
274 if (!match_pathspec(pattern
, ce
->name
, ce_namelen(ce
), 0, m
))
276 item
= string_list_insert(list
, ce
->name
);
277 if (ce_skip_worktree(ce
))
278 item
->util
= item
; /* better a valid pointer than a fake one */
281 return report_path_error(m
, pattern
, prefix
);
284 static void add_remove_files(struct string_list
*list
)
287 for (i
= 0; i
< list
->nr
; i
++) {
289 struct string_list_item
*p
= &(list
->items
[i
]);
291 /* p->util is skip-worktree */
295 if (!lstat(p
->string
, &st
)) {
296 if (add_to_cache(p
->string
, &st
, 0))
297 die(_("updating files failed"));
299 remove_file_from_cache(p
->string
);
303 static void create_base_index(const struct commit
*current_head
)
306 struct unpack_trees_options opts
;
314 memset(&opts
, 0, sizeof(opts
));
318 opts
.src_index
= &the_index
;
319 opts
.dst_index
= &the_index
;
321 opts
.fn
= oneway_merge
;
322 tree
= parse_tree_indirect(current_head
->object
.sha1
);
324 die(_("failed to unpack HEAD tree object"));
326 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
327 if (unpack_trees(1, &t
, &opts
))
328 exit(128); /* We've already reported the error, finish dying */
331 static void refresh_cache_or_die(int refresh_flags
)
334 * refresh_flags contains REFRESH_QUIET, so the only errors
335 * are for unmerged entries.
337 if (refresh_cache(refresh_flags
| REFRESH_IN_PORCELAIN
))
338 die_resolve_conflict("commit");
341 static char *prepare_index(int argc
, const char **argv
, const char *prefix
,
342 const struct commit
*current_head
, int is_status
)
345 struct string_list partial
;
346 const char **pathspec
= NULL
;
347 char *old_index_env
= NULL
;
348 int refresh_flags
= REFRESH_QUIET
;
351 refresh_flags
|= REFRESH_UNMERGED
;
354 pathspec
= get_pathspec(prefix
, argv
);
356 if (read_cache_preload(pathspec
) < 0)
357 die(_("index file corrupt"));
360 fd
= hold_locked_index(&index_lock
, 1);
362 refresh_cache_or_die(refresh_flags
);
364 if (write_cache(fd
, active_cache
, active_nr
) ||
365 close_lock_file(&index_lock
))
366 die(_("unable to create temporary index"));
368 old_index_env
= getenv(INDEX_ENVIRONMENT
);
369 setenv(INDEX_ENVIRONMENT
, index_lock
.filename
, 1);
371 if (interactive_add(argc
, argv
, prefix
, patch_interactive
) != 0)
372 die(_("interactive add failed"));
374 if (old_index_env
&& *old_index_env
)
375 setenv(INDEX_ENVIRONMENT
, old_index_env
, 1);
377 unsetenv(INDEX_ENVIRONMENT
);
380 read_cache_from(index_lock
.filename
);
382 commit_style
= COMMIT_NORMAL
;
383 return index_lock
.filename
;
387 * Non partial, non as-is commit.
389 * (1) get the real index;
390 * (2) update the_index as necessary;
391 * (3) write the_index out to the real index (still locked);
392 * (4) return the name of the locked index file.
394 * The caller should run hooks on the locked real index, and
395 * (A) if all goes well, commit the real index;
396 * (B) on failure, rollback the real index.
398 if (all
|| (also
&& pathspec
&& *pathspec
)) {
399 fd
= hold_locked_index(&index_lock
, 1);
400 add_files_to_cache(also
? prefix
: NULL
, pathspec
, 0);
401 refresh_cache_or_die(refresh_flags
);
402 if (write_cache(fd
, active_cache
, active_nr
) ||
403 close_lock_file(&index_lock
))
404 die(_("unable to write new_index file"));
405 commit_style
= COMMIT_NORMAL
;
406 return index_lock
.filename
;
412 * (1) return the name of the real index file.
414 * The caller should run hooks on the real index,
415 * and create commit from the_index.
416 * We still need to refresh the index here.
418 if (!pathspec
|| !*pathspec
) {
419 fd
= hold_locked_index(&index_lock
, 1);
420 refresh_cache_or_die(refresh_flags
);
421 if (active_cache_changed
) {
422 if (write_cache(fd
, active_cache
, active_nr
) ||
423 commit_locked_index(&index_lock
))
424 die(_("unable to write new_index file"));
426 rollback_lock_file(&index_lock
);
428 commit_style
= COMMIT_AS_IS
;
429 return get_index_file();
435 * (0) find the set of affected paths;
436 * (1) get lock on the real index file;
437 * (2) update the_index with the given paths;
438 * (3) write the_index out to the real index (still locked);
439 * (4) get lock on the false index file;
440 * (5) reset the_index from HEAD;
441 * (6) update the_index the same way as (2);
442 * (7) write the_index out to the false index file;
443 * (8) return the name of the false index file (still locked);
445 * The caller should run hooks on the locked false index, and
446 * create commit from it. Then
447 * (A) if all goes well, commit the real index;
448 * (B) on failure, rollback the real index;
449 * In either case, rollback the false index.
451 commit_style
= COMMIT_PARTIAL
;
453 if (whence
!= FROM_COMMIT
)
454 die(_("cannot do a partial commit during a %s."), whence_s());
456 memset(&partial
, 0, sizeof(partial
));
457 partial
.strdup_strings
= 1;
458 if (list_paths(&partial
, !current_head
? NULL
: "HEAD", prefix
, pathspec
))
462 if (read_cache() < 0)
463 die(_("cannot read the index"));
465 fd
= hold_locked_index(&index_lock
, 1);
466 add_remove_files(&partial
);
467 refresh_cache(REFRESH_QUIET
);
468 if (write_cache(fd
, active_cache
, active_nr
) ||
469 close_lock_file(&index_lock
))
470 die(_("unable to write new_index file"));
472 fd
= hold_lock_file_for_update(&false_lock
,
473 git_path("next-index-%"PRIuMAX
,
474 (uintmax_t) getpid()),
477 create_base_index(current_head
);
478 add_remove_files(&partial
);
479 refresh_cache(REFRESH_QUIET
);
481 if (write_cache(fd
, active_cache
, active_nr
) ||
482 close_lock_file(&false_lock
))
483 die(_("unable to write temporary index file"));
486 read_cache_from(false_lock
.filename
);
488 return false_lock
.filename
;
491 static int run_status(FILE *fp
, const char *index_file
, const char *prefix
, int nowarn
,
494 unsigned char sha1
[20];
496 if (s
->relative_paths
)
501 s
->reference
= "HEAD^1";
503 s
->verbose
= verbose
;
504 s
->index_file
= index_file
;
507 s
->is_initial
= get_sha1(s
->reference
, sha1
) ? 1 : 0;
509 wt_status_collect(s
);
511 switch (status_format
) {
512 case STATUS_FORMAT_SHORT
:
513 wt_shortstatus_print(s
, null_termination
, status_show_branch
);
515 case STATUS_FORMAT_PORCELAIN
:
516 wt_porcelain_print(s
, null_termination
);
518 case STATUS_FORMAT_LONG
:
523 return s
->commitable
;
526 static int is_a_merge(const struct commit
*current_head
)
528 return !!(current_head
->parents
&& current_head
->parents
->next
);
531 static const char sign_off_header
[] = "Signed-off-by: ";
533 static void determine_author_info(struct strbuf
*author_ident
)
535 char *name
, *email
, *date
;
537 name
= getenv("GIT_AUTHOR_NAME");
538 email
= getenv("GIT_AUTHOR_EMAIL");
539 date
= getenv("GIT_AUTHOR_DATE");
541 if (author_message
) {
542 const char *a
, *lb
, *rb
, *eol
;
544 a
= strstr(author_message_buffer
, "\nauthor ");
546 die(_("invalid commit: %s"), author_message
);
548 lb
= strchrnul(a
+ strlen("\nauthor "), '<');
549 rb
= strchrnul(lb
, '>');
550 eol
= strchrnul(rb
, '\n');
551 if (!*lb
|| !*rb
|| !*eol
)
552 die(_("invalid commit: %s"), author_message
);
554 if (lb
== a
+ strlen("\nauthor "))
555 /* \nauthor <foo@example.com> */
556 name
= xcalloc(1, 1);
558 name
= xmemdupz(a
+ strlen("\nauthor "),
560 (a
+ strlen("\nauthor "))));
561 email
= xmemdupz(lb
+ strlen("<"), rb
- (lb
+ strlen("<")));
562 date
= xmemdupz(rb
+ strlen("> "), eol
- (rb
+ strlen("> ")));
566 const char *lb
= strstr(force_author
, " <");
567 const char *rb
= strchr(force_author
, '>');
570 die(_("malformed --author parameter"));
571 name
= xstrndup(force_author
, lb
- force_author
);
572 email
= xstrndup(lb
+ 2, rb
- (lb
+ 2));
577 strbuf_addstr(author_ident
, fmt_ident(name
, email
, date
,
578 IDENT_ERROR_ON_NO_NAME
));
581 static int ends_rfc2822_footer(struct strbuf
*sb
)
588 const char *buf
= sb
->buf
;
590 for (i
= len
- 1; i
> 0; i
--) {
591 if (hit
&& buf
[i
] == '\n')
593 hit
= (buf
[i
] == '\n');
596 while (i
< len
- 1 && buf
[i
] == '\n')
599 for (; i
< len
; i
= k
) {
600 for (k
= i
; k
< len
&& buf
[k
] != '\n'; k
++)
604 if ((buf
[k
] == ' ' || buf
[k
] == '\t') && !first
)
609 for (j
= 0; i
+ j
< len
; j
++) {
622 static char *cut_ident_timestamp_part(char *string
)
624 char *ket
= strrchr(string
, '>');
625 if (!ket
|| ket
[1] != ' ')
626 die(_("Malformed ident string: '%s'"), string
);
631 static int prepare_to_commit(const char *index_file
, const char *prefix
,
632 struct commit
*current_head
,
634 struct strbuf
*author_ident
)
637 struct strbuf committer_ident
= STRBUF_INIT
;
638 int commitable
, saved_color_setting
;
639 struct strbuf sb
= STRBUF_INIT
;
641 const char *hook_arg1
= NULL
;
642 const char *hook_arg2
= NULL
;
644 int clean_message_contents
= (cleanup_mode
!= CLEANUP_NONE
);
646 if (!no_verify
&& run_hook(index_file
, "pre-commit", NULL
))
649 if (squash_message
) {
651 * Insert the proper subject line before other commit
652 * message options add their content.
654 if (use_message
&& !strcmp(use_message
, squash_message
))
655 strbuf_addstr(&sb
, "squash! ");
657 struct pretty_print_context ctx
= {0};
659 c
= lookup_commit_reference_by_name(squash_message
);
661 die(_("could not lookup commit %s"), squash_message
);
662 ctx
.output_encoding
= get_commit_output_encoding();
663 format_commit_message(c
, "squash! %s\n\n", &sb
,
669 strbuf_addbuf(&sb
, &message
);
670 hook_arg1
= "message";
671 } else if (logfile
&& !strcmp(logfile
, "-")) {
673 fprintf(stderr
, _("(reading log message from standard input)\n"));
674 if (strbuf_read(&sb
, 0, 0) < 0)
675 die_errno(_("could not read log from standard input"));
676 hook_arg1
= "message";
677 } else if (logfile
) {
678 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
679 die_errno(_("could not read log file '%s'"),
681 hook_arg1
= "message";
682 } else if (use_message
) {
683 buffer
= strstr(use_message_buffer
, "\n\n");
684 if (!buffer
|| buffer
[2] == '\0')
685 die(_("commit has empty message"));
686 strbuf_add(&sb
, buffer
+ 2, strlen(buffer
+ 2));
687 hook_arg1
= "commit";
688 hook_arg2
= use_message
;
689 } else if (fixup_message
) {
690 struct pretty_print_context ctx
= {0};
691 struct commit
*commit
;
692 commit
= lookup_commit_reference_by_name(fixup_message
);
694 die(_("could not lookup commit %s"), fixup_message
);
695 ctx
.output_encoding
= get_commit_output_encoding();
696 format_commit_message(commit
, "fixup! %s\n\n",
698 hook_arg1
= "message";
699 } else if (!stat(git_path("MERGE_MSG"), &statbuf
)) {
700 if (strbuf_read_file(&sb
, git_path("MERGE_MSG"), 0) < 0)
701 die_errno(_("could not read MERGE_MSG"));
703 } else if (!stat(git_path("SQUASH_MSG"), &statbuf
)) {
704 if (strbuf_read_file(&sb
, git_path("SQUASH_MSG"), 0) < 0)
705 die_errno(_("could not read SQUASH_MSG"));
706 hook_arg1
= "squash";
707 } else if (template_file
) {
708 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
709 die_errno(_("could not read '%s'"), template_file
);
710 hook_arg1
= "template";
711 clean_message_contents
= 0;
715 * The remaining cases don't modify the template message, but
716 * just set the argument(s) to the prepare-commit-msg hook.
718 else if (whence
== FROM_MERGE
)
720 else if (whence
== FROM_CHERRY_PICK
) {
721 hook_arg1
= "commit";
722 hook_arg2
= "CHERRY_PICK_HEAD";
725 if (squash_message
) {
727 * If squash_commit was used for the commit subject,
728 * then we're possibly hijacking other commit log options.
729 * Reset the hook args to tell the real story.
731 hook_arg1
= "message";
735 s
->fp
= fopen(git_path(commit_editmsg
), "w");
737 die_errno(_("could not open '%s'"), git_path(commit_editmsg
));
739 if (clean_message_contents
)
743 struct strbuf sob
= STRBUF_INIT
;
746 strbuf_addstr(&sob
, sign_off_header
);
747 strbuf_addstr(&sob
, fmt_name(getenv("GIT_COMMITTER_NAME"),
748 getenv("GIT_COMMITTER_EMAIL")));
749 strbuf_addch(&sob
, '\n');
750 for (i
= sb
.len
- 1; i
> 0 && sb
.buf
[i
- 1] != '\n'; i
--)
752 if (prefixcmp(sb
.buf
+ i
, sob
.buf
)) {
753 if (!i
|| !ends_rfc2822_footer(&sb
))
754 strbuf_addch(&sb
, '\n');
755 strbuf_addbuf(&sb
, &sob
);
757 strbuf_release(&sob
);
760 if (fwrite(sb
.buf
, 1, sb
.len
, s
->fp
) < sb
.len
)
761 die_errno(_("could not write commit template"));
765 /* This checks and barfs if author is badly specified */
766 determine_author_info(author_ident
);
768 /* This checks if committer ident is explicitly given */
769 strbuf_addstr(&committer_ident
, git_committer_info(0));
770 if (use_editor
&& include_status
) {
771 char *ai_tmp
, *ci_tmp
;
772 if (whence
!= FROM_COMMIT
)
773 status_printf_ln(s
, GIT_COLOR_NORMAL
,
775 "It looks like you may be committing a %s.\n"
776 "If this is not correct, please remove the file\n"
781 git_path(whence
== FROM_MERGE
783 : "CHERRY_PICK_HEAD"));
785 fprintf(s
->fp
, "\n");
786 status_printf(s
, GIT_COLOR_NORMAL
,
787 _("Please enter the commit message for your changes."));
788 if (cleanup_mode
== CLEANUP_ALL
)
789 status_printf_more(s
, GIT_COLOR_NORMAL
,
790 _(" Lines starting\n"
791 "with '#' will be ignored, and an empty"
792 " message aborts the commit.\n"));
793 else /* CLEANUP_SPACE, that is. */
794 status_printf_more(s
, GIT_COLOR_NORMAL
,
795 _(" Lines starting\n"
796 "with '#' will be kept; you may remove them"
797 " yourself if you want to.\n"
798 "An empty message aborts the commit.\n"));
799 if (only_include_assumed
)
800 status_printf_ln(s
, GIT_COLOR_NORMAL
,
801 "%s", only_include_assumed
);
803 ai_tmp
= cut_ident_timestamp_part(author_ident
->buf
);
804 ci_tmp
= cut_ident_timestamp_part(committer_ident
.buf
);
805 if (strcmp(author_ident
->buf
, committer_ident
.buf
))
806 status_printf_ln(s
, GIT_COLOR_NORMAL
,
809 ident_shown
++ ? "" : "\n",
812 if (!user_ident_sufficiently_given())
813 status_printf_ln(s
, GIT_COLOR_NORMAL
,
816 ident_shown
++ ? "" : "\n",
817 committer_ident
.buf
);
820 status_printf_ln(s
, GIT_COLOR_NORMAL
, "");
822 saved_color_setting
= s
->use_color
;
824 commitable
= run_status(s
->fp
, index_file
, prefix
, 1, s
);
825 s
->use_color
= saved_color_setting
;
830 unsigned char sha1
[20];
831 const char *parent
= "HEAD";
833 if (!active_nr
&& read_cache() < 0)
834 die(_("Cannot read index"));
839 if (get_sha1(parent
, sha1
))
840 commitable
= !!active_nr
;
842 commitable
= index_differs_from(parent
, 0);
844 strbuf_release(&committer_ident
);
849 * Reject an attempt to record a non-merge empty commit without
850 * explicit --allow-empty. In the cherry-pick case, it may be
851 * empty due to conflict resolution, which the user should okay.
853 if (!commitable
&& whence
!= FROM_MERGE
&& !allow_empty
&&
854 !(amend
&& is_a_merge(current_head
))) {
855 run_status(stdout
, index_file
, prefix
, 0, s
);
857 fputs(_(empty_amend_advice
), stderr
);
858 else if (whence
== FROM_CHERRY_PICK
)
859 fputs(_(empty_cherry_pick_advice
), stderr
);
864 * Re-read the index as pre-commit hook could have updated it,
865 * and write it out as a tree. We must do this before we invoke
866 * the editor and after we invoke run_status above.
869 read_cache_from(index_file
);
870 if (!active_cache_tree
)
871 active_cache_tree
= cache_tree();
872 if (cache_tree_update(active_cache_tree
,
873 active_cache
, active_nr
, 0, 0) < 0) {
874 error(_("Error building trees"));
878 if (run_hook(index_file
, "prepare-commit-msg",
879 git_path(commit_editmsg
), hook_arg1
, hook_arg2
, NULL
))
883 char index
[PATH_MAX
];
884 const char *env
[2] = { NULL
};
886 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
887 if (launch_editor(git_path(commit_editmsg
), NULL
, env
)) {
889 _("Please supply the message using either -m or -F option.\n"));
895 run_hook(index_file
, "commit-msg", git_path(commit_editmsg
), NULL
)) {
903 * Find out if the message in the strbuf contains only whitespace and
904 * Signed-off-by lines.
906 static int message_is_empty(struct strbuf
*sb
)
908 struct strbuf tmpl
= STRBUF_INIT
;
910 int eol
, i
, start
= 0;
912 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
915 /* See if the template is just a prefix of the message. */
916 if (template_file
&& strbuf_read_file(&tmpl
, template_file
, 0) > 0) {
917 stripspace(&tmpl
, cleanup_mode
== CLEANUP_ALL
);
918 if (start
+ tmpl
.len
<= sb
->len
&&
919 memcmp(tmpl
.buf
, sb
->buf
+ start
, tmpl
.len
) == 0)
922 strbuf_release(&tmpl
);
924 /* Check if the rest is just whitespace and Signed-of-by's. */
925 for (i
= start
; i
< sb
->len
; i
++) {
926 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
932 if (strlen(sign_off_header
) <= eol
- i
&&
933 !prefixcmp(sb
->buf
+ i
, sign_off_header
)) {
938 if (!isspace(sb
->buf
[i
++]))
945 static const char *find_author_by_nickname(const char *name
)
947 struct rev_info revs
;
948 struct commit
*commit
;
949 struct strbuf buf
= STRBUF_INIT
;
953 init_revisions(&revs
, NULL
);
954 strbuf_addf(&buf
, "--author=%s", name
);
959 setup_revisions(ac
, av
, &revs
, NULL
);
960 prepare_revision_walk(&revs
);
961 commit
= get_revision(&revs
);
963 struct pretty_print_context ctx
= {0};
964 ctx
.date_mode
= DATE_NORMAL
;
965 strbuf_release(&buf
);
966 format_commit_message(commit
, "%an <%ae>", &buf
, &ctx
);
967 return strbuf_detach(&buf
, NULL
);
969 die(_("No existing author found with '%s'"), name
);
973 static void handle_untracked_files_arg(struct wt_status
*s
)
975 if (!untracked_files_arg
)
976 ; /* default already initialized */
977 else if (!strcmp(untracked_files_arg
, "no"))
978 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
979 else if (!strcmp(untracked_files_arg
, "normal"))
980 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
981 else if (!strcmp(untracked_files_arg
, "all"))
982 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
984 die(_("Invalid untracked files mode '%s'"), untracked_files_arg
);
987 static const char *read_commit_message(const char *name
)
989 const char *out_enc
, *out
;
990 struct commit
*commit
;
992 commit
= lookup_commit_reference_by_name(name
);
994 die(_("could not lookup commit %s"), name
);
995 out_enc
= get_commit_output_encoding();
996 out
= logmsg_reencode(commit
, out_enc
);
999 * If we failed to reencode the buffer, just copy it
1000 * byte for byte so the user can try to fix it up.
1001 * This also handles the case where input and output
1002 * encodings are identical.
1005 out
= xstrdup(commit
->buffer
);
1009 static int parse_and_validate_options(int argc
, const char *argv
[],
1010 const char * const usage
[],
1012 struct commit
*current_head
,
1013 struct wt_status
*s
)
1017 argc
= parse_options(argc
, argv
, prefix
, builtin_commit_options
, usage
,
1020 if (force_author
&& !strchr(force_author
, '>'))
1021 force_author
= find_author_by_nickname(force_author
);
1023 if (force_author
&& renew_authorship
)
1024 die(_("Using both --reset-author and --author does not make sense"));
1026 if (logfile
|| message
.len
|| use_message
|| fixup_message
)
1031 setenv("GIT_EDITOR", ":", 1);
1033 /* Sanity check options */
1034 if (amend
&& !current_head
)
1035 die(_("You have nothing to amend."));
1036 if (amend
&& whence
!= FROM_COMMIT
)
1037 die(_("You are in the middle of a %s -- cannot amend."), whence_s());
1038 if (fixup_message
&& squash_message
)
1039 die(_("Options --squash and --fixup cannot be used together"));
1049 die(_("Only one of -c/-C/-F/--fixup can be used."));
1050 if (message
.len
&& f
> 0)
1051 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1053 use_message
= edit_message
;
1054 if (amend
&& !use_message
&& !fixup_message
)
1055 use_message
= "HEAD";
1056 if (!use_message
&& whence
!= FROM_CHERRY_PICK
&& renew_authorship
)
1057 die(_("--reset-author can be used only with -C, -c or --amend."));
1059 use_message_buffer
= read_commit_message(use_message
);
1060 if (!renew_authorship
) {
1061 author_message
= use_message
;
1062 author_message_buffer
= use_message_buffer
;
1065 if (whence
== FROM_CHERRY_PICK
&& !renew_authorship
) {
1066 author_message
= "CHERRY_PICK_HEAD";
1067 author_message_buffer
= read_commit_message(author_message
);
1070 if (patch_interactive
)
1073 if (!!also
+ !!only
+ !!all
+ !!interactive
> 1)
1074 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1075 if (argc
== 0 && (also
|| (only
&& !amend
)))
1076 die(_("No paths with --include/--only does not make sense."));
1077 if (argc
== 0 && only
&& amend
)
1078 only_include_assumed
= _("Clever... amending the last one with dirty index.");
1079 if (argc
> 0 && !also
&& !only
)
1080 only_include_assumed
= _("Explicit paths specified without -i nor -o; assuming --only paths...");
1081 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
1082 cleanup_mode
= use_editor
? CLEANUP_ALL
: CLEANUP_SPACE
;
1083 else if (!strcmp(cleanup_arg
, "verbatim"))
1084 cleanup_mode
= CLEANUP_NONE
;
1085 else if (!strcmp(cleanup_arg
, "whitespace"))
1086 cleanup_mode
= CLEANUP_SPACE
;
1087 else if (!strcmp(cleanup_arg
, "strip"))
1088 cleanup_mode
= CLEANUP_ALL
;
1090 die(_("Invalid cleanup mode %s"), cleanup_arg
);
1092 handle_untracked_files_arg(s
);
1094 if (all
&& argc
> 0)
1095 die(_("Paths with -a does not make sense."));
1097 if (null_termination
&& status_format
== STATUS_FORMAT_LONG
)
1098 status_format
= STATUS_FORMAT_PORCELAIN
;
1099 if (status_format
!= STATUS_FORMAT_LONG
)
1105 static int dry_run_commit(int argc
, const char **argv
, const char *prefix
,
1106 const struct commit
*current_head
, struct wt_status
*s
)
1109 const char *index_file
;
1111 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 1);
1112 commitable
= run_status(stdout
, index_file
, prefix
, 0, s
);
1113 rollback_index_files();
1115 return commitable
? 0 : 1;
1118 static int parse_status_slot(const char *var
, int offset
)
1120 if (!strcasecmp(var
+offset
, "header"))
1121 return WT_STATUS_HEADER
;
1122 if (!strcasecmp(var
+offset
, "branch"))
1123 return WT_STATUS_ONBRANCH
;
1124 if (!strcasecmp(var
+offset
, "updated")
1125 || !strcasecmp(var
+offset
, "added"))
1126 return WT_STATUS_UPDATED
;
1127 if (!strcasecmp(var
+offset
, "changed"))
1128 return WT_STATUS_CHANGED
;
1129 if (!strcasecmp(var
+offset
, "untracked"))
1130 return WT_STATUS_UNTRACKED
;
1131 if (!strcasecmp(var
+offset
, "nobranch"))
1132 return WT_STATUS_NOBRANCH
;
1133 if (!strcasecmp(var
+offset
, "unmerged"))
1134 return WT_STATUS_UNMERGED
;
1138 static int git_status_config(const char *k
, const char *v
, void *cb
)
1140 struct wt_status
*s
= cb
;
1142 if (!strcmp(k
, "status.submodulesummary")) {
1144 s
->submodule_summary
= git_config_bool_or_int(k
, v
, &is_bool
);
1145 if (is_bool
&& s
->submodule_summary
)
1146 s
->submodule_summary
= -1;
1149 if (!strcmp(k
, "status.color") || !strcmp(k
, "color.status")) {
1150 s
->use_color
= git_config_colorbool(k
, v
);
1153 if (!prefixcmp(k
, "status.color.") || !prefixcmp(k
, "color.status.")) {
1154 int slot
= parse_status_slot(k
, 13);
1158 return config_error_nonbool(k
);
1159 color_parse(v
, k
, s
->color_palette
[slot
]);
1162 if (!strcmp(k
, "status.relativepaths")) {
1163 s
->relative_paths
= git_config_bool(k
, v
);
1166 if (!strcmp(k
, "status.showuntrackedfiles")) {
1168 return config_error_nonbool(k
);
1169 else if (!strcmp(v
, "no"))
1170 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1171 else if (!strcmp(v
, "normal"))
1172 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1173 else if (!strcmp(v
, "all"))
1174 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1176 return error(_("Invalid untracked files mode '%s'"), v
);
1179 return git_diff_ui_config(k
, v
, NULL
);
1182 int cmd_status(int argc
, const char **argv
, const char *prefix
)
1186 unsigned char sha1
[20];
1187 static struct option builtin_status_options
[] = {
1188 OPT__VERBOSE(&verbose
, "be verbose"),
1189 OPT_SET_INT('s', "short", &status_format
,
1190 "show status concisely", STATUS_FORMAT_SHORT
),
1191 OPT_BOOLEAN('b', "branch", &status_show_branch
,
1192 "show branch information"),
1193 OPT_SET_INT(0, "porcelain", &status_format
,
1194 "machine-readable output",
1195 STATUS_FORMAT_PORCELAIN
),
1196 OPT_BOOLEAN('z', "null", &null_termination
,
1197 "terminate entries with NUL"),
1198 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
,
1200 "show untracked files, optional modes: all, normal, no. (Default: all)",
1201 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1202 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status
,
1203 "show ignored files"),
1204 { OPTION_STRING
, 0, "ignore-submodules", &ignore_submodule_arg
, "when",
1205 "ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)",
1206 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1210 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1211 usage_with_options(builtin_status_usage
, builtin_status_options
);
1213 wt_status_prepare(&s
);
1214 gitmodules_config();
1215 git_config(git_status_config
, &s
);
1216 determine_whence(&s
);
1217 argc
= parse_options(argc
, argv
, prefix
,
1218 builtin_status_options
,
1219 builtin_status_usage
, 0);
1221 if (null_termination
&& status_format
== STATUS_FORMAT_LONG
)
1222 status_format
= STATUS_FORMAT_PORCELAIN
;
1224 handle_untracked_files_arg(&s
);
1225 if (show_ignored_in_status
)
1226 s
.show_ignored_files
= 1;
1228 s
.pathspec
= get_pathspec(prefix
, argv
);
1230 read_cache_preload(s
.pathspec
);
1231 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, s
.pathspec
, NULL
, NULL
);
1233 fd
= hold_locked_index(&index_lock
, 0);
1235 update_index_if_able(&the_index
, &index_lock
);
1237 s
.is_initial
= get_sha1(s
.reference
, sha1
) ? 1 : 0;
1238 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1239 wt_status_collect(&s
);
1241 if (s
.relative_paths
)
1244 switch (status_format
) {
1245 case STATUS_FORMAT_SHORT
:
1246 wt_shortstatus_print(&s
, null_termination
, status_show_branch
);
1248 case STATUS_FORMAT_PORCELAIN
:
1249 wt_porcelain_print(&s
, null_termination
);
1251 case STATUS_FORMAT_LONG
:
1252 s
.verbose
= verbose
;
1253 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1254 wt_status_print(&s
);
1260 static void print_summary(const char *prefix
, const unsigned char *sha1
,
1263 struct rev_info rev
;
1264 struct commit
*commit
;
1265 struct strbuf format
= STRBUF_INIT
;
1266 unsigned char junk_sha1
[20];
1267 const char *head
= resolve_ref("HEAD", junk_sha1
, 0, NULL
);
1268 struct pretty_print_context pctx
= {0};
1269 struct strbuf author_ident
= STRBUF_INIT
;
1270 struct strbuf committer_ident
= STRBUF_INIT
;
1272 commit
= lookup_commit(sha1
);
1274 die(_("couldn't look up newly created commit"));
1275 if (!commit
|| parse_commit(commit
))
1276 die(_("could not parse newly created commit"));
1278 strbuf_addstr(&format
, "format:%h] %s");
1280 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1281 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1282 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1283 strbuf_addstr(&format
, "\n Author: ");
1284 strbuf_addbuf_percentquote(&format
, &author_ident
);
1286 if (!user_ident_sufficiently_given()) {
1287 strbuf_addstr(&format
, "\n Committer: ");
1288 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1289 if (advice_implicit_identity
) {
1290 strbuf_addch(&format
, '\n');
1291 strbuf_addstr(&format
, _(implicit_ident_advice
));
1294 strbuf_release(&author_ident
);
1295 strbuf_release(&committer_ident
);
1297 init_revisions(&rev
, prefix
);
1298 setup_revisions(0, NULL
, &rev
, NULL
);
1301 rev
.diffopt
.output_format
=
1302 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1304 rev
.verbose_header
= 1;
1305 rev
.show_root_diff
= 1;
1306 get_commit_format(format
.buf
, &rev
);
1307 rev
.always_show_header
= 0;
1308 rev
.diffopt
.detect_rename
= 1;
1309 rev
.diffopt
.break_opt
= 0;
1310 diff_setup_done(&rev
.diffopt
);
1313 !prefixcmp(head
, "refs/heads/") ?
1315 !strcmp(head
, "HEAD") ?
1316 _("detached HEAD") :
1318 initial_commit
? _(" (root-commit)") : "");
1320 if (!log_tree_commit(&rev
, commit
)) {
1321 rev
.always_show_header
= 1;
1322 rev
.use_terminator
= 1;
1323 log_tree_commit(&rev
, commit
);
1326 strbuf_release(&format
);
1329 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1331 struct wt_status
*s
= cb
;
1334 if (!strcmp(k
, "commit.template"))
1335 return git_config_pathname(&template_file
, k
, v
);
1336 if (!strcmp(k
, "commit.status")) {
1337 include_status
= git_config_bool(k
, v
);
1340 status
= git_gpg_config(k
, v
, NULL
);
1343 return git_status_config(k
, v
, s
);
1346 static const char post_rewrite_hook
[] = "hooks/post-rewrite";
1348 static int run_rewrite_hook(const unsigned char *oldsha1
,
1349 const unsigned char *newsha1
)
1351 /* oldsha1 SP newsha1 LF NUL */
1352 static char buf
[2*40 + 3];
1353 struct child_process proc
;
1354 const char *argv
[3];
1358 if (access(git_path(post_rewrite_hook
), X_OK
) < 0)
1361 argv
[0] = git_path(post_rewrite_hook
);
1365 memset(&proc
, 0, sizeof(proc
));
1368 proc
.stdout_to_stderr
= 1;
1370 code
= start_command(&proc
);
1373 n
= snprintf(buf
, sizeof(buf
), "%s %s\n",
1374 sha1_to_hex(oldsha1
), sha1_to_hex(newsha1
));
1375 write_in_full(proc
.in
, buf
, n
);
1377 return finish_command(&proc
);
1380 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1382 struct strbuf sb
= STRBUF_INIT
;
1383 struct strbuf author_ident
= STRBUF_INIT
;
1384 const char *index_file
, *reflog_msg
;
1386 unsigned char sha1
[20];
1387 struct ref_lock
*ref_lock
;
1388 struct commit_list
*parents
= NULL
, **pptr
= &parents
;
1389 struct stat statbuf
;
1390 int allow_fast_forward
= 1;
1392 struct commit
*current_head
= NULL
;
1394 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1395 usage_with_options(builtin_commit_usage
, builtin_commit_options
);
1397 wt_status_prepare(&s
);
1398 git_config(git_commit_config
, &s
);
1399 determine_whence(&s
);
1401 if (get_sha1("HEAD", sha1
))
1402 current_head
= NULL
;
1404 current_head
= lookup_commit_or_die(sha1
, "HEAD");
1405 if (!current_head
|| parse_commit(current_head
))
1406 die(_("could not parse HEAD commit"));
1408 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_usage
,
1409 prefix
, current_head
, &s
);
1411 return dry_run_commit(argc
, argv
, prefix
, current_head
, &s
);
1412 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 0);
1414 /* Set up everything for writing the commit object. This includes
1415 running hooks, writing the trees, and interacting with the user. */
1416 if (!prepare_to_commit(index_file
, prefix
,
1417 current_head
, &s
, &author_ident
)) {
1418 rollback_index_files();
1422 /* Determine parents */
1423 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1424 if (!current_head
) {
1426 reflog_msg
= "commit (initial)";
1428 struct commit_list
*c
;
1431 reflog_msg
= "commit (amend)";
1432 for (c
= current_head
->parents
; c
; c
= c
->next
)
1433 pptr
= &commit_list_insert(c
->item
, pptr
)->next
;
1434 } else if (whence
== FROM_MERGE
) {
1435 struct strbuf m
= STRBUF_INIT
;
1436 struct commit
*commit
;
1440 reflog_msg
= "commit (merge)";
1441 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1442 fp
= fopen(git_path("MERGE_HEAD"), "r");
1444 die_errno(_("could not open '%s' for reading"),
1445 git_path("MERGE_HEAD"));
1446 while (strbuf_getline(&m
, fp
, '\n') != EOF
) {
1447 unsigned char sha1
[20];
1448 if (get_sha1_hex(m
.buf
, sha1
) < 0)
1449 die(_("Corrupt MERGE_HEAD file (%s)"), m
.buf
);
1450 commit
= lookup_commit_or_die(sha1
, "MERGE_HEAD");
1451 pptr
= &commit_list_insert(commit
, pptr
)->next
;
1455 if (!stat(git_path("MERGE_MODE"), &statbuf
)) {
1456 if (strbuf_read_file(&sb
, git_path("MERGE_MODE"), 0) < 0)
1457 die_errno(_("could not read MERGE_MODE"));
1458 if (!strcmp(sb
.buf
, "no-ff"))
1459 allow_fast_forward
= 0;
1461 if (allow_fast_forward
)
1462 parents
= reduce_heads(parents
);
1465 reflog_msg
= (whence
== FROM_CHERRY_PICK
)
1466 ? "commit (cherry-pick)"
1468 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1471 /* Finally, get the commit message */
1473 if (strbuf_read_file(&sb
, git_path(commit_editmsg
), 0) < 0) {
1474 int saved_errno
= errno
;
1475 rollback_index_files();
1476 die(_("could not read commit message: %s"), strerror(saved_errno
));
1479 /* Truncate the message just before the diff, if any. */
1481 p
= strstr(sb
.buf
, "\ndiff --git ");
1483 strbuf_setlen(&sb
, p
- sb
.buf
+ 1);
1486 if (cleanup_mode
!= CLEANUP_NONE
)
1487 stripspace(&sb
, cleanup_mode
== CLEANUP_ALL
);
1488 if (message_is_empty(&sb
) && !allow_empty_message
) {
1489 rollback_index_files();
1490 fprintf(stderr
, _("Aborting commit due to empty commit message.\n"));
1494 if (commit_tree(sb
.buf
, active_cache_tree
->sha1
, parents
, sha1
,
1495 author_ident
.buf
, sign_commit
)) {
1496 rollback_index_files();
1497 die(_("failed to write commit object"));
1499 strbuf_release(&author_ident
);
1501 ref_lock
= lock_any_ref_for_update("HEAD",
1504 : current_head
->object
.sha1
,
1507 nl
= strchr(sb
.buf
, '\n');
1509 strbuf_setlen(&sb
, nl
+ 1 - sb
.buf
);
1511 strbuf_addch(&sb
, '\n');
1512 strbuf_insert(&sb
, 0, reflog_msg
, strlen(reflog_msg
));
1513 strbuf_insert(&sb
, strlen(reflog_msg
), ": ", 2);
1516 rollback_index_files();
1517 die(_("cannot lock HEAD ref"));
1519 if (write_ref_sha1(ref_lock
, sha1
, sb
.buf
) < 0) {
1520 rollback_index_files();
1521 die(_("cannot update HEAD ref"));
1524 unlink(git_path("CHERRY_PICK_HEAD"));
1525 unlink(git_path("MERGE_HEAD"));
1526 unlink(git_path("MERGE_MSG"));
1527 unlink(git_path("MERGE_MODE"));
1528 unlink(git_path("SQUASH_MSG"));
1530 if (commit_index_files())
1531 die (_("Repository has been updated, but unable to write\n"
1532 "new_index file. Check that disk is not full or quota is\n"
1533 "not exceeded, and then \"git reset HEAD\" to recover."));
1536 run_hook(get_index_file(), "post-commit", NULL
);
1537 if (amend
&& !no_post_rewrite
) {
1538 struct notes_rewrite_cfg
*cfg
;
1539 cfg
= init_copy_notes_for_rewrite("amend");
1541 /* we are amending, so current_head is not NULL */
1542 copy_note_for_rewrite(cfg
, current_head
->object
.sha1
, sha1
);
1543 finish_copy_notes_for_rewrite(cfg
);
1545 run_rewrite_hook(current_head
->object
.sha1
, sha1
);
1548 print_summary(prefix
, sha1
, !current_head
);