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
, 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.
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
;
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
;
121 strbuf_setlen(buf
, 0);
123 strbuf_addstr(buf
, arg
);
124 strbuf_addstr(buf
, "\n\n");
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
},
180 static void determine_whence(struct wt_status
*s
)
182 if (file_exists(git_path("MERGE_HEAD")))
184 else if (file_exists(git_path("CHERRY_PICK_HEAD")))
185 whence
= FROM_CHERRY_PICK
;
187 whence
= FROM_COMMIT
;
192 static const char *whence_s(void)
202 case FROM_CHERRY_PICK
:
210 static void rollback_index_files(void)
212 switch (commit_style
) {
214 break; /* nothing to do */
216 rollback_lock_file(&index_lock
);
219 rollback_lock_file(&index_lock
);
220 rollback_lock_file(&false_lock
);
225 static int commit_index_files(void)
229 switch (commit_style
) {
231 break; /* nothing to do */
233 err
= commit_lock_file(&index_lock
);
236 err
= commit_lock_file(&index_lock
);
237 rollback_lock_file(&false_lock
);
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
)
254 for (i
= 0; pattern
[i
]; i
++)
259 char *max_prefix
= common_prefix(pattern
);
260 overlay_tree_on_cache(with_tree
, max_prefix
? max_prefix
: 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
)
270 if (!match_pathspec(pattern
, ce
->name
, ce_namelen(ce
), 0, m
))
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
)
283 for (i
= 0; i
< list
->nr
; i
++) {
285 struct string_list_item
*p
= &(list
->items
[i
]);
287 /* p->util is skip-worktree */
291 if (!lstat(p
->string
, &st
)) {
292 if (add_to_cache(p
->string
, &st
, 0))
293 die(_("updating files failed"));
295 remove_file_from_cache(p
->string
);
299 static void create_base_index(const struct commit
*current_head
)
302 struct unpack_trees_options opts
;
310 memset(&opts
, 0, sizeof(opts
));
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
);
320 die(_("failed to unpack HEAD tree object"));
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
)
341 struct string_list partial
;
342 const char **pathspec
= NULL
;
343 char *old_index_env
= NULL
;
344 int refresh_flags
= REFRESH_QUIET
;
347 refresh_flags
|= REFRESH_UNMERGED
;
350 pathspec
= get_pathspec(prefix
, argv
);
352 if (read_cache_preload(pathspec
) < 0)
353 die(_("index file corrupt"));
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);
373 unsetenv(INDEX_ENVIRONMENT
);
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 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 if (write_cache(fd
, active_cache
, active_nr
) ||
419 commit_locked_index(&index_lock
))
420 die(_("unable to write new_index file"));
422 rollback_lock_file(&index_lock
);
424 commit_style
= COMMIT_AS_IS
;
425 return get_index_file();
431 * (0) find the set of affected paths;
432 * (1) get lock on the real index file;
433 * (2) update the_index with the given paths;
434 * (3) write the_index out to the real index (still locked);
435 * (4) get lock on the false index file;
436 * (5) reset the_index from HEAD;
437 * (6) update the_index the same way as (2);
438 * (7) write the_index out to the false index file;
439 * (8) return the name of the false index file (still locked);
441 * The caller should run hooks on the locked false index, and
442 * create commit from it. Then
443 * (A) if all goes well, commit the real index;
444 * (B) on failure, rollback the real index;
445 * In either case, rollback the false index.
447 commit_style
= COMMIT_PARTIAL
;
449 if (whence
!= FROM_COMMIT
)
450 die(_("cannot do a partial commit during a %s."), whence_s());
452 memset(&partial
, 0, sizeof(partial
));
453 partial
.strdup_strings
= 1;
454 if (list_paths(&partial
, !current_head
? NULL
: "HEAD", prefix
, pathspec
))
458 if (read_cache() < 0)
459 die(_("cannot read the index"));
461 fd
= hold_locked_index(&index_lock
, 1);
462 add_remove_files(&partial
);
463 refresh_cache(REFRESH_QUIET
);
464 if (write_cache(fd
, active_cache
, active_nr
) ||
465 close_lock_file(&index_lock
))
466 die(_("unable to write new_index file"));
468 fd
= hold_lock_file_for_update(&false_lock
,
469 git_path("next-index-%"PRIuMAX
,
470 (uintmax_t) getpid()),
473 create_base_index(current_head
);
474 add_remove_files(&partial
);
475 refresh_cache(REFRESH_QUIET
);
477 if (write_cache(fd
, active_cache
, active_nr
) ||
478 close_lock_file(&false_lock
))
479 die(_("unable to write temporary index file"));
482 read_cache_from(false_lock
.filename
);
484 return false_lock
.filename
;
487 static int run_status(FILE *fp
, const char *index_file
, const char *prefix
, int nowarn
,
490 unsigned char sha1
[20];
492 if (s
->relative_paths
)
497 s
->reference
= "HEAD^1";
499 s
->verbose
= verbose
;
500 s
->index_file
= index_file
;
503 s
->is_initial
= get_sha1(s
->reference
, sha1
) ? 1 : 0;
505 wt_status_collect(s
);
507 switch (status_format
) {
508 case STATUS_FORMAT_SHORT
:
509 wt_shortstatus_print(s
, null_termination
, status_show_branch
);
511 case STATUS_FORMAT_PORCELAIN
:
512 wt_porcelain_print(s
, null_termination
);
514 case STATUS_FORMAT_LONG
:
519 return s
->commitable
;
522 static int is_a_merge(const struct commit
*current_head
)
524 return !!(current_head
->parents
&& current_head
->parents
->next
);
527 static const char sign_off_header
[] = "Signed-off-by: ";
529 static void determine_author_info(struct strbuf
*author_ident
)
531 char *name
, *email
, *date
;
533 name
= getenv("GIT_AUTHOR_NAME");
534 email
= getenv("GIT_AUTHOR_EMAIL");
535 date
= getenv("GIT_AUTHOR_DATE");
537 if (author_message
) {
538 const char *a
, *lb
, *rb
, *eol
;
540 a
= strstr(author_message_buffer
, "\nauthor ");
542 die(_("invalid commit: %s"), author_message
);
544 lb
= strchrnul(a
+ strlen("\nauthor "), '<');
545 rb
= strchrnul(lb
, '>');
546 eol
= strchrnul(rb
, '\n');
547 if (!*lb
|| !*rb
|| !*eol
)
548 die(_("invalid commit: %s"), author_message
);
550 if (lb
== a
+ strlen("\nauthor "))
551 /* \nauthor <foo@example.com> */
552 name
= xcalloc(1, 1);
554 name
= xmemdupz(a
+ strlen("\nauthor "),
556 (a
+ strlen("\nauthor "))));
557 email
= xmemdupz(lb
+ strlen("<"), rb
- (lb
+ strlen("<")));
558 date
= xmemdupz(rb
+ strlen("> "), eol
- (rb
+ strlen("> ")));
562 const char *lb
= strstr(force_author
, " <");
563 const char *rb
= strchr(force_author
, '>');
566 die(_("malformed --author parameter"));
567 name
= xstrndup(force_author
, lb
- force_author
);
568 email
= xstrndup(lb
+ 2, rb
- (lb
+ 2));
573 strbuf_addstr(author_ident
, fmt_ident(name
, email
, date
,
574 IDENT_ERROR_ON_NO_NAME
));
577 static int ends_rfc2822_footer(struct strbuf
*sb
)
584 const char *buf
= sb
->buf
;
586 for (i
= len
- 1; i
> 0; i
--) {
587 if (hit
&& buf
[i
] == '\n')
589 hit
= (buf
[i
] == '\n');
592 while (i
< len
- 1 && buf
[i
] == '\n')
595 for (; i
< len
; i
= k
) {
596 for (k
= i
; k
< len
&& buf
[k
] != '\n'; k
++)
600 if ((buf
[k
] == ' ' || buf
[k
] == '\t') && !first
)
605 for (j
= 0; i
+ j
< len
; j
++) {
618 static char *cut_ident_timestamp_part(char *string
)
620 char *ket
= strrchr(string
, '>');
621 if (!ket
|| ket
[1] != ' ')
622 die(_("Malformed ident string: '%s'"), string
);
627 static int prepare_to_commit(const char *index_file
, const char *prefix
,
628 struct commit
*current_head
,
630 struct strbuf
*author_ident
)
633 struct strbuf committer_ident
= STRBUF_INIT
;
634 int commitable
, saved_color_setting
;
635 struct strbuf sb
= STRBUF_INIT
;
637 const char *hook_arg1
= NULL
;
638 const char *hook_arg2
= NULL
;
640 int clean_message_contents
= (cleanup_mode
!= CLEANUP_NONE
);
642 if (!no_verify
&& run_hook(index_file
, "pre-commit", NULL
))
645 if (squash_message
) {
647 * Insert the proper subject line before other commit
648 * message options add their content.
650 if (use_message
&& !strcmp(use_message
, squash_message
))
651 strbuf_addstr(&sb
, "squash! ");
653 struct pretty_print_context ctx
= {0};
655 c
= lookup_commit_reference_by_name(squash_message
);
657 die(_("could not lookup commit %s"), squash_message
);
658 ctx
.output_encoding
= get_commit_output_encoding();
659 format_commit_message(c
, "squash! %s\n\n", &sb
,
665 strbuf_addbuf(&sb
, &message
);
666 hook_arg1
= "message";
667 } else if (logfile
&& !strcmp(logfile
, "-")) {
669 fprintf(stderr
, _("(reading log message from standard input)\n"));
670 if (strbuf_read(&sb
, 0, 0) < 0)
671 die_errno(_("could not read log from standard input"));
672 hook_arg1
= "message";
673 } else if (logfile
) {
674 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
675 die_errno(_("could not read log file '%s'"),
677 hook_arg1
= "message";
678 } else if (use_message
) {
679 buffer
= strstr(use_message_buffer
, "\n\n");
680 if (!buffer
|| buffer
[2] == '\0')
681 die(_("commit has empty message"));
682 strbuf_add(&sb
, buffer
+ 2, strlen(buffer
+ 2));
683 hook_arg1
= "commit";
684 hook_arg2
= use_message
;
685 } else if (fixup_message
) {
686 struct pretty_print_context ctx
= {0};
687 struct commit
*commit
;
688 commit
= lookup_commit_reference_by_name(fixup_message
);
690 die(_("could not lookup commit %s"), fixup_message
);
691 ctx
.output_encoding
= get_commit_output_encoding();
692 format_commit_message(commit
, "fixup! %s\n\n",
694 hook_arg1
= "message";
695 } else if (!stat(git_path("MERGE_MSG"), &statbuf
)) {
696 if (strbuf_read_file(&sb
, git_path("MERGE_MSG"), 0) < 0)
697 die_errno(_("could not read MERGE_MSG"));
699 } else if (!stat(git_path("SQUASH_MSG"), &statbuf
)) {
700 if (strbuf_read_file(&sb
, git_path("SQUASH_MSG"), 0) < 0)
701 die_errno(_("could not read SQUASH_MSG"));
702 hook_arg1
= "squash";
703 } else if (template_file
) {
704 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
705 die_errno(_("could not read '%s'"), template_file
);
706 hook_arg1
= "template";
707 clean_message_contents
= 0;
711 * The remaining cases don't modify the template message, but
712 * just set the argument(s) to the prepare-commit-msg hook.
714 else if (whence
== FROM_MERGE
)
716 else if (whence
== FROM_CHERRY_PICK
) {
717 hook_arg1
= "commit";
718 hook_arg2
= "CHERRY_PICK_HEAD";
721 if (squash_message
) {
723 * If squash_commit was used for the commit subject,
724 * then we're possibly hijacking other commit log options.
725 * Reset the hook args to tell the real story.
727 hook_arg1
= "message";
731 s
->fp
= fopen(git_path(commit_editmsg
), "w");
733 die_errno(_("could not open '%s'"), git_path(commit_editmsg
));
735 if (clean_message_contents
)
739 struct strbuf sob
= STRBUF_INIT
;
742 strbuf_addstr(&sob
, sign_off_header
);
743 strbuf_addstr(&sob
, fmt_name(getenv("GIT_COMMITTER_NAME"),
744 getenv("GIT_COMMITTER_EMAIL")));
745 strbuf_addch(&sob
, '\n');
746 for (i
= sb
.len
- 1; i
> 0 && sb
.buf
[i
- 1] != '\n'; i
--)
748 if (prefixcmp(sb
.buf
+ i
, sob
.buf
)) {
749 if (!i
|| !ends_rfc2822_footer(&sb
))
750 strbuf_addch(&sb
, '\n');
751 strbuf_addbuf(&sb
, &sob
);
753 strbuf_release(&sob
);
756 if (fwrite(sb
.buf
, 1, sb
.len
, s
->fp
) < sb
.len
)
757 die_errno(_("could not write commit template"));
761 /* This checks and barfs if author is badly specified */
762 determine_author_info(author_ident
);
764 /* This checks if committer ident is explicitly given */
765 strbuf_addstr(&committer_ident
, git_committer_info(0));
766 if (use_editor
&& include_status
) {
767 char *ai_tmp
, *ci_tmp
;
768 if (whence
!= FROM_COMMIT
)
769 status_printf_ln(s
, GIT_COLOR_NORMAL
,
771 "It looks like you may be committing a %s.\n"
772 "If this is not correct, please remove the file\n"
777 git_path(whence
== FROM_MERGE
779 : "CHERRY_PICK_HEAD"));
781 fprintf(s
->fp
, "\n");
782 status_printf(s
, GIT_COLOR_NORMAL
,
783 _("Please enter the commit message for your changes."));
784 if (cleanup_mode
== CLEANUP_ALL
)
785 status_printf_more(s
, GIT_COLOR_NORMAL
,
786 _(" Lines starting\n"
787 "with '#' will be ignored, and an empty"
788 " message aborts the commit.\n"));
789 else /* CLEANUP_SPACE, that is. */
790 status_printf_more(s
, GIT_COLOR_NORMAL
,
791 _(" Lines starting\n"
792 "with '#' will be kept; you may remove them"
793 " yourself if you want to.\n"
794 "An empty message aborts the commit.\n"));
795 if (only_include_assumed
)
796 status_printf_ln(s
, GIT_COLOR_NORMAL
,
797 "%s", only_include_assumed
);
799 ai_tmp
= cut_ident_timestamp_part(author_ident
->buf
);
800 ci_tmp
= cut_ident_timestamp_part(committer_ident
.buf
);
801 if (strcmp(author_ident
->buf
, committer_ident
.buf
))
802 status_printf_ln(s
, GIT_COLOR_NORMAL
,
805 ident_shown
++ ? "" : "\n",
808 if (!user_ident_sufficiently_given())
809 status_printf_ln(s
, GIT_COLOR_NORMAL
,
812 ident_shown
++ ? "" : "\n",
813 committer_ident
.buf
);
816 status_printf_ln(s
, GIT_COLOR_NORMAL
, "");
818 saved_color_setting
= s
->use_color
;
820 commitable
= run_status(s
->fp
, index_file
, prefix
, 1, s
);
821 s
->use_color
= saved_color_setting
;
826 unsigned char sha1
[20];
827 const char *parent
= "HEAD";
829 if (!active_nr
&& read_cache() < 0)
830 die(_("Cannot read index"));
835 if (get_sha1(parent
, sha1
))
836 commitable
= !!active_nr
;
838 commitable
= index_differs_from(parent
, 0);
840 strbuf_release(&committer_ident
);
845 * Reject an attempt to record a non-merge empty commit without
846 * explicit --allow-empty. In the cherry-pick case, it may be
847 * empty due to conflict resolution, which the user should okay.
849 if (!commitable
&& whence
!= FROM_MERGE
&& !allow_empty
&&
850 !(amend
&& is_a_merge(current_head
))) {
851 run_status(stdout
, index_file
, prefix
, 0, s
);
853 fputs(_(empty_amend_advice
), stderr
);
854 else if (whence
== FROM_CHERRY_PICK
)
855 fputs(_(empty_cherry_pick_advice
), stderr
);
860 * Re-read the index as pre-commit hook could have updated it,
861 * and write it out as a tree. We must do this before we invoke
862 * the editor and after we invoke run_status above.
865 read_cache_from(index_file
);
866 if (!active_cache_tree
)
867 active_cache_tree
= cache_tree();
868 if (cache_tree_update(active_cache_tree
,
869 active_cache
, active_nr
, 0, 0) < 0) {
870 error(_("Error building trees"));
874 if (run_hook(index_file
, "prepare-commit-msg",
875 git_path(commit_editmsg
), hook_arg1
, hook_arg2
, NULL
))
879 char index
[PATH_MAX
];
880 const char *env
[2] = { NULL
};
882 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
883 if (launch_editor(git_path(commit_editmsg
), NULL
, env
)) {
885 _("Please supply the message using either -m or -F option.\n"));
891 run_hook(index_file
, "commit-msg", git_path(commit_editmsg
), NULL
)) {
899 * Find out if the message in the strbuf contains only whitespace and
900 * Signed-off-by lines.
902 static int message_is_empty(struct strbuf
*sb
)
904 struct strbuf tmpl
= STRBUF_INIT
;
906 int eol
, i
, start
= 0;
908 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
911 /* See if the template is just a prefix of the message. */
912 if (template_file
&& strbuf_read_file(&tmpl
, template_file
, 0) > 0) {
913 stripspace(&tmpl
, cleanup_mode
== CLEANUP_ALL
);
914 if (start
+ tmpl
.len
<= sb
->len
&&
915 memcmp(tmpl
.buf
, sb
->buf
+ start
, tmpl
.len
) == 0)
918 strbuf_release(&tmpl
);
920 /* Check if the rest is just whitespace and Signed-of-by's. */
921 for (i
= start
; i
< sb
->len
; i
++) {
922 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
928 if (strlen(sign_off_header
) <= eol
- i
&&
929 !prefixcmp(sb
->buf
+ i
, sign_off_header
)) {
934 if (!isspace(sb
->buf
[i
++]))
941 static const char *find_author_by_nickname(const char *name
)
943 struct rev_info revs
;
944 struct commit
*commit
;
945 struct strbuf buf
= STRBUF_INIT
;
949 init_revisions(&revs
, NULL
);
950 strbuf_addf(&buf
, "--author=%s", name
);
955 setup_revisions(ac
, av
, &revs
, NULL
);
956 prepare_revision_walk(&revs
);
957 commit
= get_revision(&revs
);
959 struct pretty_print_context ctx
= {0};
960 ctx
.date_mode
= DATE_NORMAL
;
961 strbuf_release(&buf
);
962 format_commit_message(commit
, "%an <%ae>", &buf
, &ctx
);
963 return strbuf_detach(&buf
, NULL
);
965 die(_("No existing author found with '%s'"), name
);
969 static void handle_untracked_files_arg(struct wt_status
*s
)
971 if (!untracked_files_arg
)
972 ; /* default already initialized */
973 else if (!strcmp(untracked_files_arg
, "no"))
974 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
975 else if (!strcmp(untracked_files_arg
, "normal"))
976 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
977 else if (!strcmp(untracked_files_arg
, "all"))
978 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
980 die(_("Invalid untracked files mode '%s'"), untracked_files_arg
);
983 static const char *read_commit_message(const char *name
)
985 const char *out_enc
, *out
;
986 struct commit
*commit
;
988 commit
= lookup_commit_reference_by_name(name
);
990 die(_("could not lookup commit %s"), name
);
991 out_enc
= get_commit_output_encoding();
992 out
= logmsg_reencode(commit
, out_enc
);
995 * If we failed to reencode the buffer, just copy it
996 * byte for byte so the user can try to fix it up.
997 * This also handles the case where input and output
998 * encodings are identical.
1001 out
= xstrdup(commit
->buffer
);
1005 static int parse_and_validate_options(int argc
, const char *argv
[],
1006 const char * const usage
[],
1008 struct commit
*current_head
,
1009 struct wt_status
*s
)
1013 argc
= parse_options(argc
, argv
, prefix
, builtin_commit_options
, usage
,
1016 if (force_author
&& !strchr(force_author
, '>'))
1017 force_author
= find_author_by_nickname(force_author
);
1019 if (force_author
&& renew_authorship
)
1020 die(_("Using both --reset-author and --author does not make sense"));
1022 if (logfile
|| message
.len
|| use_message
|| fixup_message
)
1025 use_editor
= edit_flag
;
1027 setenv("GIT_EDITOR", ":", 1);
1029 /* Sanity check options */
1030 if (amend
&& !current_head
)
1031 die(_("You have nothing to amend."));
1032 if (amend
&& whence
!= FROM_COMMIT
)
1033 die(_("You are in the middle of a %s -- cannot amend."), whence_s());
1034 if (fixup_message
&& squash_message
)
1035 die(_("Options --squash and --fixup cannot be used together"));
1045 die(_("Only one of -c/-C/-F/--fixup can be used."));
1046 if (message
.len
&& f
> 0)
1047 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1049 use_message
= edit_message
;
1050 if (amend
&& !use_message
&& !fixup_message
)
1051 use_message
= "HEAD";
1052 if (!use_message
&& whence
!= FROM_CHERRY_PICK
&& renew_authorship
)
1053 die(_("--reset-author can be used only with -C, -c or --amend."));
1055 use_message_buffer
= read_commit_message(use_message
);
1056 if (!renew_authorship
) {
1057 author_message
= use_message
;
1058 author_message_buffer
= use_message_buffer
;
1061 if (whence
== FROM_CHERRY_PICK
&& !renew_authorship
) {
1062 author_message
= "CHERRY_PICK_HEAD";
1063 author_message_buffer
= read_commit_message(author_message
);
1066 if (patch_interactive
)
1069 if (!!also
+ !!only
+ !!all
+ !!interactive
> 1)
1070 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1071 if (argc
== 0 && (also
|| (only
&& !amend
)))
1072 die(_("No paths with --include/--only does not make sense."));
1073 if (argc
== 0 && only
&& amend
)
1074 only_include_assumed
= _("Clever... amending the last one with dirty index.");
1075 if (argc
> 0 && !also
&& !only
)
1076 only_include_assumed
= _("Explicit paths specified without -i nor -o; assuming --only paths...");
1077 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
1078 cleanup_mode
= use_editor
? CLEANUP_ALL
: CLEANUP_SPACE
;
1079 else if (!strcmp(cleanup_arg
, "verbatim"))
1080 cleanup_mode
= CLEANUP_NONE
;
1081 else if (!strcmp(cleanup_arg
, "whitespace"))
1082 cleanup_mode
= CLEANUP_SPACE
;
1083 else if (!strcmp(cleanup_arg
, "strip"))
1084 cleanup_mode
= CLEANUP_ALL
;
1086 die(_("Invalid cleanup mode %s"), cleanup_arg
);
1088 handle_untracked_files_arg(s
);
1090 if (all
&& argc
> 0)
1091 die(_("Paths with -a does not make sense."));
1093 if (null_termination
&& status_format
== STATUS_FORMAT_LONG
)
1094 status_format
= STATUS_FORMAT_PORCELAIN
;
1095 if (status_format
!= STATUS_FORMAT_LONG
)
1101 static int dry_run_commit(int argc
, const char **argv
, const char *prefix
,
1102 const struct commit
*current_head
, struct wt_status
*s
)
1105 const char *index_file
;
1107 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 1);
1108 commitable
= run_status(stdout
, index_file
, prefix
, 0, s
);
1109 rollback_index_files();
1111 return commitable
? 0 : 1;
1114 static int parse_status_slot(const char *var
, int offset
)
1116 if (!strcasecmp(var
+offset
, "header"))
1117 return WT_STATUS_HEADER
;
1118 if (!strcasecmp(var
+offset
, "branch"))
1119 return WT_STATUS_ONBRANCH
;
1120 if (!strcasecmp(var
+offset
, "updated")
1121 || !strcasecmp(var
+offset
, "added"))
1122 return WT_STATUS_UPDATED
;
1123 if (!strcasecmp(var
+offset
, "changed"))
1124 return WT_STATUS_CHANGED
;
1125 if (!strcasecmp(var
+offset
, "untracked"))
1126 return WT_STATUS_UNTRACKED
;
1127 if (!strcasecmp(var
+offset
, "nobranch"))
1128 return WT_STATUS_NOBRANCH
;
1129 if (!strcasecmp(var
+offset
, "unmerged"))
1130 return WT_STATUS_UNMERGED
;
1134 static int git_status_config(const char *k
, const char *v
, void *cb
)
1136 struct wt_status
*s
= cb
;
1138 if (!strcmp(k
, "status.submodulesummary")) {
1140 s
->submodule_summary
= git_config_bool_or_int(k
, v
, &is_bool
);
1141 if (is_bool
&& s
->submodule_summary
)
1142 s
->submodule_summary
= -1;
1145 if (!strcmp(k
, "status.color") || !strcmp(k
, "color.status")) {
1146 s
->use_color
= git_config_colorbool(k
, v
);
1149 if (!prefixcmp(k
, "status.color.") || !prefixcmp(k
, "color.status.")) {
1150 int slot
= parse_status_slot(k
, 13);
1154 return config_error_nonbool(k
);
1155 color_parse(v
, k
, s
->color_palette
[slot
]);
1158 if (!strcmp(k
, "status.relativepaths")) {
1159 s
->relative_paths
= git_config_bool(k
, v
);
1162 if (!strcmp(k
, "status.showuntrackedfiles")) {
1164 return config_error_nonbool(k
);
1165 else if (!strcmp(v
, "no"))
1166 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1167 else if (!strcmp(v
, "normal"))
1168 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1169 else if (!strcmp(v
, "all"))
1170 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1172 return error(_("Invalid untracked files mode '%s'"), v
);
1175 return git_diff_ui_config(k
, v
, NULL
);
1178 int cmd_status(int argc
, const char **argv
, const char *prefix
)
1182 unsigned char sha1
[20];
1183 static struct option builtin_status_options
[] = {
1184 OPT__VERBOSE(&verbose
, "be verbose"),
1185 OPT_SET_INT('s', "short", &status_format
,
1186 "show status concisely", STATUS_FORMAT_SHORT
),
1187 OPT_BOOLEAN('b', "branch", &status_show_branch
,
1188 "show branch information"),
1189 OPT_SET_INT(0, "porcelain", &status_format
,
1190 "machine-readable output",
1191 STATUS_FORMAT_PORCELAIN
),
1192 OPT_BOOLEAN('z', "null", &null_termination
,
1193 "terminate entries with NUL"),
1194 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
,
1196 "show untracked files, optional modes: all, normal, no. (Default: all)",
1197 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1198 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status
,
1199 "show ignored files"),
1200 { OPTION_STRING
, 0, "ignore-submodules", &ignore_submodule_arg
, "when",
1201 "ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)",
1202 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1206 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1207 usage_with_options(builtin_status_usage
, builtin_status_options
);
1209 wt_status_prepare(&s
);
1210 gitmodules_config();
1211 git_config(git_status_config
, &s
);
1212 determine_whence(&s
);
1213 argc
= parse_options(argc
, argv
, prefix
,
1214 builtin_status_options
,
1215 builtin_status_usage
, 0);
1217 if (null_termination
&& status_format
== STATUS_FORMAT_LONG
)
1218 status_format
= STATUS_FORMAT_PORCELAIN
;
1220 handle_untracked_files_arg(&s
);
1221 if (show_ignored_in_status
)
1222 s
.show_ignored_files
= 1;
1224 s
.pathspec
= get_pathspec(prefix
, argv
);
1226 read_cache_preload(s
.pathspec
);
1227 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, s
.pathspec
, NULL
, NULL
);
1229 fd
= hold_locked_index(&index_lock
, 0);
1231 update_index_if_able(&the_index
, &index_lock
);
1233 s
.is_initial
= get_sha1(s
.reference
, sha1
) ? 1 : 0;
1234 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1235 wt_status_collect(&s
);
1237 if (s
.relative_paths
)
1240 switch (status_format
) {
1241 case STATUS_FORMAT_SHORT
:
1242 wt_shortstatus_print(&s
, null_termination
, status_show_branch
);
1244 case STATUS_FORMAT_PORCELAIN
:
1245 wt_porcelain_print(&s
, null_termination
);
1247 case STATUS_FORMAT_LONG
:
1248 s
.verbose
= verbose
;
1249 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1250 wt_status_print(&s
);
1256 static void print_summary(const char *prefix
, const unsigned char *sha1
,
1259 struct rev_info rev
;
1260 struct commit
*commit
;
1261 struct strbuf format
= STRBUF_INIT
;
1262 unsigned char junk_sha1
[20];
1264 struct pretty_print_context pctx
= {0};
1265 struct strbuf author_ident
= STRBUF_INIT
;
1266 struct strbuf committer_ident
= STRBUF_INIT
;
1268 commit
= lookup_commit(sha1
);
1270 die(_("couldn't look up newly created commit"));
1271 if (!commit
|| parse_commit(commit
))
1272 die(_("could not parse newly created commit"));
1274 strbuf_addstr(&format
, "format:%h] %s");
1276 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1277 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1278 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1279 strbuf_addstr(&format
, "\n Author: ");
1280 strbuf_addbuf_percentquote(&format
, &author_ident
);
1282 if (!user_ident_sufficiently_given()) {
1283 strbuf_addstr(&format
, "\n Committer: ");
1284 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1285 if (advice_implicit_identity
) {
1286 strbuf_addch(&format
, '\n');
1287 strbuf_addstr(&format
, _(implicit_ident_advice
));
1290 strbuf_release(&author_ident
);
1291 strbuf_release(&committer_ident
);
1293 init_revisions(&rev
, prefix
);
1294 setup_revisions(0, NULL
, &rev
, NULL
);
1297 rev
.diffopt
.output_format
=
1298 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1300 rev
.verbose_header
= 1;
1301 rev
.show_root_diff
= 1;
1302 get_commit_format(format
.buf
, &rev
);
1303 rev
.always_show_header
= 0;
1304 rev
.diffopt
.detect_rename
= 1;
1305 rev
.diffopt
.break_opt
= 0;
1306 diff_setup_done(&rev
.diffopt
);
1308 head
= resolve_ref("HEAD", junk_sha1
, 0, NULL
);
1310 !prefixcmp(head
, "refs/heads/") ?
1312 !strcmp(head
, "HEAD") ?
1313 _("detached HEAD") :
1315 initial_commit
? _(" (root-commit)") : "");
1317 if (!log_tree_commit(&rev
, commit
)) {
1318 rev
.always_show_header
= 1;
1319 rev
.use_terminator
= 1;
1320 log_tree_commit(&rev
, commit
);
1323 strbuf_release(&format
);
1326 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1328 struct wt_status
*s
= cb
;
1330 if (!strcmp(k
, "commit.template"))
1331 return git_config_pathname(&template_file
, k
, v
);
1332 if (!strcmp(k
, "commit.status")) {
1333 include_status
= git_config_bool(k
, v
);
1337 return git_status_config(k
, v
, s
);
1340 static const char post_rewrite_hook
[] = "hooks/post-rewrite";
1342 static int run_rewrite_hook(const unsigned char *oldsha1
,
1343 const unsigned char *newsha1
)
1345 /* oldsha1 SP newsha1 LF NUL */
1346 static char buf
[2*40 + 3];
1347 struct child_process proc
;
1348 const char *argv
[3];
1352 if (access(git_path(post_rewrite_hook
), X_OK
) < 0)
1355 argv
[0] = git_path(post_rewrite_hook
);
1359 memset(&proc
, 0, sizeof(proc
));
1362 proc
.stdout_to_stderr
= 1;
1364 code
= start_command(&proc
);
1367 n
= snprintf(buf
, sizeof(buf
), "%s %s\n",
1368 sha1_to_hex(oldsha1
), sha1_to_hex(newsha1
));
1369 write_in_full(proc
.in
, buf
, n
);
1371 return finish_command(&proc
);
1374 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1376 struct strbuf sb
= STRBUF_INIT
;
1377 struct strbuf author_ident
= STRBUF_INIT
;
1378 const char *index_file
, *reflog_msg
;
1380 unsigned char sha1
[20];
1381 struct ref_lock
*ref_lock
;
1382 struct commit_list
*parents
= NULL
, **pptr
= &parents
;
1383 struct stat statbuf
;
1384 int allow_fast_forward
= 1;
1386 struct commit
*current_head
= NULL
;
1387 struct commit_extra_header
*extra
= NULL
;
1389 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1390 usage_with_options(builtin_commit_usage
, builtin_commit_options
);
1392 wt_status_prepare(&s
);
1393 git_config(git_commit_config
, &s
);
1394 determine_whence(&s
);
1396 if (get_sha1("HEAD", sha1
))
1397 current_head
= NULL
;
1399 current_head
= lookup_commit_or_die(sha1
, "HEAD");
1400 if (!current_head
|| parse_commit(current_head
))
1401 die(_("could not parse HEAD commit"));
1403 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_usage
,
1404 prefix
, current_head
, &s
);
1406 return dry_run_commit(argc
, argv
, prefix
, current_head
, &s
);
1407 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 0);
1409 /* Set up everything for writing the commit object. This includes
1410 running hooks, writing the trees, and interacting with the user. */
1411 if (!prepare_to_commit(index_file
, prefix
,
1412 current_head
, &s
, &author_ident
)) {
1413 rollback_index_files();
1417 /* Determine parents */
1418 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1419 if (!current_head
) {
1421 reflog_msg
= "commit (initial)";
1423 struct commit_list
*c
;
1426 reflog_msg
= "commit (amend)";
1427 for (c
= current_head
->parents
; c
; c
= c
->next
)
1428 pptr
= &commit_list_insert(c
->item
, pptr
)->next
;
1429 } else if (whence
== FROM_MERGE
) {
1430 struct strbuf m
= STRBUF_INIT
;
1434 reflog_msg
= "commit (merge)";
1435 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1436 fp
= fopen(git_path("MERGE_HEAD"), "r");
1438 die_errno(_("could not open '%s' for reading"),
1439 git_path("MERGE_HEAD"));
1440 while (strbuf_getline(&m
, fp
, '\n') != EOF
) {
1441 struct commit
*parent
;
1443 parent
= get_merge_parent(m
.buf
);
1445 die(_("Corrupt MERGE_HEAD file (%s)"), m
.buf
);
1446 pptr
= &commit_list_insert(parent
, pptr
)->next
;
1450 if (!stat(git_path("MERGE_MODE"), &statbuf
)) {
1451 if (strbuf_read_file(&sb
, git_path("MERGE_MODE"), 0) < 0)
1452 die_errno(_("could not read MERGE_MODE"));
1453 if (!strcmp(sb
.buf
, "no-ff"))
1454 allow_fast_forward
= 0;
1456 if (allow_fast_forward
)
1457 parents
= reduce_heads(parents
);
1460 reflog_msg
= (whence
== FROM_CHERRY_PICK
)
1461 ? "commit (cherry-pick)"
1463 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1466 /* Finally, get the commit message */
1468 if (strbuf_read_file(&sb
, git_path(commit_editmsg
), 0) < 0) {
1469 int saved_errno
= errno
;
1470 rollback_index_files();
1471 die(_("could not read commit message: %s"), strerror(saved_errno
));
1474 /* Truncate the message just before the diff, if any. */
1476 p
= strstr(sb
.buf
, "\ndiff --git ");
1478 strbuf_setlen(&sb
, p
- sb
.buf
+ 1);
1481 if (cleanup_mode
!= CLEANUP_NONE
)
1482 stripspace(&sb
, cleanup_mode
== CLEANUP_ALL
);
1483 if (message_is_empty(&sb
) && !allow_empty_message
) {
1484 rollback_index_files();
1485 fprintf(stderr
, _("Aborting commit due to empty commit message.\n"));
1490 extra
= read_commit_extra_headers(current_head
);
1492 if (commit_tree_extended(sb
.buf
, active_cache_tree
->sha1
, parents
, sha1
,
1493 author_ident
.buf
, extra
)) {
1494 rollback_index_files();
1495 die(_("failed to write commit object"));
1497 strbuf_release(&author_ident
);
1498 free_commit_extra_headers(extra
);
1500 ref_lock
= lock_any_ref_for_update("HEAD",
1503 : current_head
->object
.sha1
,
1506 nl
= strchr(sb
.buf
, '\n');
1508 strbuf_setlen(&sb
, nl
+ 1 - sb
.buf
);
1510 strbuf_addch(&sb
, '\n');
1511 strbuf_insert(&sb
, 0, reflog_msg
, strlen(reflog_msg
));
1512 strbuf_insert(&sb
, strlen(reflog_msg
), ": ", 2);
1515 rollback_index_files();
1516 die(_("cannot lock HEAD ref"));
1518 if (write_ref_sha1(ref_lock
, sha1
, sb
.buf
) < 0) {
1519 rollback_index_files();
1520 die(_("cannot update HEAD ref"));
1523 unlink(git_path("CHERRY_PICK_HEAD"));
1524 unlink(git_path("REVERT_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
);