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
, also
, interactive
, patch_interactive
, only
, amend
, signoff
;
86 static int edit_flag
= -1; /* unspecified */
87 static int quiet
, verbose
, no_verify
, allow_empty
, dry_run
, renew_authorship
;
88 static int no_post_rewrite
, allow_empty_message
;
89 static char *untracked_files_arg
, *force_date
, *ignore_submodule_arg
;
90 static char *sign_commit
;
93 * The default commit message cleanup mode will remove the lines
94 * beginning with # (shell comments) and leading and trailing
95 * whitespaces (empty lines or containing only whitespaces)
96 * if editor is used, and only the whitespaces if the message
97 * is specified explicitly.
104 static char *cleanup_arg
;
106 static enum commit_whence whence
;
107 static int use_editor
= 1, include_status
= 1;
108 static int show_ignored_in_status
;
109 static const char *only_include_assumed
;
110 static struct strbuf message
= STRBUF_INIT
;
112 static int null_termination
;
116 STATUS_FORMAT_PORCELAIN
117 } status_format
= STATUS_FORMAT_LONG
;
118 static int status_show_branch
;
120 static int opt_parse_m(const struct option
*opt
, const char *arg
, int unset
)
122 struct strbuf
*buf
= opt
->value
;
124 strbuf_setlen(buf
, 0);
126 strbuf_addstr(buf
, arg
);
127 strbuf_addstr(buf
, "\n\n");
132 static struct option builtin_commit_options
[] = {
133 OPT__QUIET(&quiet
, "suppress summary after successful commit"),
134 OPT__VERBOSE(&verbose
, "show diff in commit message template"),
136 OPT_GROUP("Commit message options"),
137 OPT_FILENAME('F', "file", &logfile
, "read message from file"),
138 OPT_STRING(0, "author", &force_author
, "author", "override author for commit"),
139 OPT_STRING(0, "date", &force_date
, "date", "override date for commit"),
140 OPT_CALLBACK('m', "message", &message
, "message", "commit message", opt_parse_m
),
141 OPT_STRING('c', "reedit-message", &edit_message
, "commit", "reuse and edit message from specified commit"),
142 OPT_STRING('C', "reuse-message", &use_message
, "commit", "reuse message from specified commit"),
143 OPT_STRING(0, "fixup", &fixup_message
, "commit", "use autosquash formatted message to fixup specified commit"),
144 OPT_STRING(0, "squash", &squash_message
, "commit", "use autosquash formatted message to squash specified commit"),
145 OPT_BOOLEAN(0, "reset-author", &renew_authorship
, "the commit is authored by me now (used with -C/-c/--amend)"),
146 OPT_BOOLEAN('s', "signoff", &signoff
, "add Signed-off-by:"),
147 OPT_FILENAME('t', "template", &template_file
, "use specified template file"),
148 OPT_BOOL('e', "edit", &edit_flag
, "force edit of commit"),
149 OPT_STRING(0, "cleanup", &cleanup_arg
, "default", "how to strip spaces and #comments from message"),
150 OPT_BOOLEAN(0, "status", &include_status
, "include status in commit message template"),
151 { OPTION_STRING
, 'S', "gpg-sign", &sign_commit
, "key id",
152 "GPG sign commit", PARSE_OPT_OPTARG
, NULL
, (intptr_t) "" },
153 /* end commit message options */
155 OPT_GROUP("Commit contents options"),
156 OPT_BOOLEAN('a', "all", &all
, "commit all changed files"),
157 OPT_BOOLEAN('i', "include", &also
, "add specified files to index for commit"),
158 OPT_BOOLEAN(0, "interactive", &interactive
, "interactively add files"),
159 OPT_BOOLEAN('p', "patch", &patch_interactive
, "interactively add changes"),
160 OPT_BOOLEAN('o', "only", &only
, "commit only specified files"),
161 OPT_BOOLEAN('n', "no-verify", &no_verify
, "bypass pre-commit hook"),
162 OPT_BOOLEAN(0, "dry-run", &dry_run
, "show what would be committed"),
163 OPT_SET_INT(0, "short", &status_format
, "show status concisely",
164 STATUS_FORMAT_SHORT
),
165 OPT_BOOLEAN(0, "branch", &status_show_branch
, "show branch information"),
166 OPT_SET_INT(0, "porcelain", &status_format
,
167 "machine-readable output", STATUS_FORMAT_PORCELAIN
),
168 OPT_BOOLEAN('z', "null", &null_termination
,
169 "terminate entries with NUL"),
170 OPT_BOOLEAN(0, "amend", &amend
, "amend previous commit"),
171 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite
, "bypass post-rewrite hook"),
172 { 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" },
173 /* end commit contents options */
175 { OPTION_BOOLEAN
, 0, "allow-empty", &allow_empty
, NULL
,
176 "ok to record an empty change",
177 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
178 { OPTION_BOOLEAN
, 0, "allow-empty-message", &allow_empty_message
, NULL
,
179 "ok to record a change with an empty message",
180 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
185 static void determine_whence(struct wt_status
*s
)
187 if (file_exists(git_path("MERGE_HEAD")))
189 else if (file_exists(git_path("CHERRY_PICK_HEAD")))
190 whence
= FROM_CHERRY_PICK
;
192 whence
= FROM_COMMIT
;
197 static const char *whence_s(void)
207 case FROM_CHERRY_PICK
:
215 static void rollback_index_files(void)
217 switch (commit_style
) {
219 break; /* nothing to do */
221 rollback_lock_file(&index_lock
);
224 rollback_lock_file(&index_lock
);
225 rollback_lock_file(&false_lock
);
230 static int commit_index_files(void)
234 switch (commit_style
) {
236 break; /* nothing to do */
238 err
= commit_lock_file(&index_lock
);
241 err
= commit_lock_file(&index_lock
);
242 rollback_lock_file(&false_lock
);
250 * Take a union of paths in the index and the named tree (typically, "HEAD"),
251 * and return the paths that match the given pattern in list.
253 static int list_paths(struct string_list
*list
, const char *with_tree
,
254 const char *prefix
, const char **pattern
)
259 for (i
= 0; pattern
[i
]; i
++)
264 char *max_prefix
= common_prefix(pattern
);
265 overlay_tree_on_cache(with_tree
, max_prefix
? max_prefix
: prefix
);
269 for (i
= 0; i
< active_nr
; i
++) {
270 struct cache_entry
*ce
= active_cache
[i
];
271 struct string_list_item
*item
;
273 if (ce
->ce_flags
& CE_UPDATE
)
275 if (!match_pathspec(pattern
, ce
->name
, ce_namelen(ce
), 0, m
))
277 item
= string_list_insert(list
, ce
->name
);
278 if (ce_skip_worktree(ce
))
279 item
->util
= item
; /* better a valid pointer than a fake one */
282 return report_path_error(m
, pattern
, prefix
);
285 static void add_remove_files(struct string_list
*list
)
288 for (i
= 0; i
< list
->nr
; i
++) {
290 struct string_list_item
*p
= &(list
->items
[i
]);
292 /* p->util is skip-worktree */
296 if (!lstat(p
->string
, &st
)) {
297 if (add_to_cache(p
->string
, &st
, 0))
298 die(_("updating files failed"));
300 remove_file_from_cache(p
->string
);
304 static void create_base_index(const struct commit
*current_head
)
307 struct unpack_trees_options opts
;
315 memset(&opts
, 0, sizeof(opts
));
319 opts
.src_index
= &the_index
;
320 opts
.dst_index
= &the_index
;
322 opts
.fn
= oneway_merge
;
323 tree
= parse_tree_indirect(current_head
->object
.sha1
);
325 die(_("failed to unpack HEAD tree object"));
327 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
328 if (unpack_trees(1, &t
, &opts
))
329 exit(128); /* We've already reported the error, finish dying */
332 static void refresh_cache_or_die(int refresh_flags
)
335 * refresh_flags contains REFRESH_QUIET, so the only errors
336 * are for unmerged entries.
338 if (refresh_cache(refresh_flags
| REFRESH_IN_PORCELAIN
))
339 die_resolve_conflict("commit");
342 static char *prepare_index(int argc
, const char **argv
, const char *prefix
,
343 const struct commit
*current_head
, int is_status
)
346 struct string_list partial
;
347 const char **pathspec
= NULL
;
348 char *old_index_env
= NULL
;
349 int refresh_flags
= REFRESH_QUIET
;
352 refresh_flags
|= REFRESH_UNMERGED
;
355 pathspec
= get_pathspec(prefix
, argv
);
357 if (read_cache_preload(pathspec
) < 0)
358 die(_("index file corrupt"));
361 fd
= hold_locked_index(&index_lock
, 1);
363 refresh_cache_or_die(refresh_flags
);
365 if (write_cache(fd
, active_cache
, active_nr
) ||
366 close_lock_file(&index_lock
))
367 die(_("unable to create temporary index"));
369 old_index_env
= getenv(INDEX_ENVIRONMENT
);
370 setenv(INDEX_ENVIRONMENT
, index_lock
.filename
, 1);
372 if (interactive_add(argc
, argv
, prefix
, patch_interactive
) != 0)
373 die(_("interactive add failed"));
375 if (old_index_env
&& *old_index_env
)
376 setenv(INDEX_ENVIRONMENT
, old_index_env
, 1);
378 unsetenv(INDEX_ENVIRONMENT
);
381 read_cache_from(index_lock
.filename
);
383 commit_style
= COMMIT_NORMAL
;
384 return index_lock
.filename
;
388 * Non partial, non as-is commit.
390 * (1) get the real index;
391 * (2) update the_index as necessary;
392 * (3) write the_index out to the real index (still locked);
393 * (4) return the name of the locked index file.
395 * The caller should run hooks on the locked real index, and
396 * (A) if all goes well, commit the real index;
397 * (B) on failure, rollback the real index.
399 if (all
|| (also
&& pathspec
&& *pathspec
)) {
400 fd
= hold_locked_index(&index_lock
, 1);
401 add_files_to_cache(also
? prefix
: NULL
, pathspec
, 0);
402 refresh_cache_or_die(refresh_flags
);
403 update_main_cache_tree(WRITE_TREE_SILENT
);
404 if (write_cache(fd
, active_cache
, active_nr
) ||
405 close_lock_file(&index_lock
))
406 die(_("unable to write new_index file"));
407 commit_style
= COMMIT_NORMAL
;
408 return index_lock
.filename
;
414 * (1) return the name of the real index file.
416 * The caller should run hooks on the real index,
417 * and create commit from the_index.
418 * We still need to refresh the index here.
420 if (!pathspec
|| !*pathspec
) {
421 fd
= hold_locked_index(&index_lock
, 1);
422 refresh_cache_or_die(refresh_flags
);
423 if (active_cache_changed
) {
424 update_main_cache_tree(WRITE_TREE_SILENT
);
425 if (write_cache(fd
, active_cache
, active_nr
) ||
426 commit_locked_index(&index_lock
))
427 die(_("unable to write new_index file"));
429 rollback_lock_file(&index_lock
);
431 commit_style
= COMMIT_AS_IS
;
432 return get_index_file();
438 * (0) find the set of affected paths;
439 * (1) get lock on the real index file;
440 * (2) update the_index with the given paths;
441 * (3) write the_index out to the real index (still locked);
442 * (4) get lock on the false index file;
443 * (5) reset the_index from HEAD;
444 * (6) update the_index the same way as (2);
445 * (7) write the_index out to the false index file;
446 * (8) return the name of the false index file (still locked);
448 * The caller should run hooks on the locked false index, and
449 * create commit from it. Then
450 * (A) if all goes well, commit the real index;
451 * (B) on failure, rollback the real index;
452 * In either case, rollback the false index.
454 commit_style
= COMMIT_PARTIAL
;
456 if (whence
!= FROM_COMMIT
)
457 die(_("cannot do a partial commit during a %s."), whence_s());
459 memset(&partial
, 0, sizeof(partial
));
460 partial
.strdup_strings
= 1;
461 if (list_paths(&partial
, !current_head
? NULL
: "HEAD", prefix
, pathspec
))
465 if (read_cache() < 0)
466 die(_("cannot read the index"));
468 fd
= hold_locked_index(&index_lock
, 1);
469 add_remove_files(&partial
);
470 refresh_cache(REFRESH_QUIET
);
471 if (write_cache(fd
, active_cache
, active_nr
) ||
472 close_lock_file(&index_lock
))
473 die(_("unable to write new_index file"));
475 fd
= hold_lock_file_for_update(&false_lock
,
476 git_path("next-index-%"PRIuMAX
,
477 (uintmax_t) getpid()),
480 create_base_index(current_head
);
481 add_remove_files(&partial
);
482 refresh_cache(REFRESH_QUIET
);
484 if (write_cache(fd
, active_cache
, active_nr
) ||
485 close_lock_file(&false_lock
))
486 die(_("unable to write temporary index file"));
489 read_cache_from(false_lock
.filename
);
491 return false_lock
.filename
;
494 static int run_status(FILE *fp
, const char *index_file
, const char *prefix
, int nowarn
,
497 unsigned char sha1
[20];
499 if (s
->relative_paths
)
504 s
->reference
= "HEAD^1";
506 s
->verbose
= verbose
;
507 s
->index_file
= index_file
;
510 s
->is_initial
= get_sha1(s
->reference
, sha1
) ? 1 : 0;
512 wt_status_collect(s
);
514 switch (status_format
) {
515 case STATUS_FORMAT_SHORT
:
516 wt_shortstatus_print(s
, null_termination
, status_show_branch
);
518 case STATUS_FORMAT_PORCELAIN
:
519 wt_porcelain_print(s
, null_termination
);
521 case STATUS_FORMAT_LONG
:
526 return s
->commitable
;
529 static int is_a_merge(const struct commit
*current_head
)
531 return !!(current_head
->parents
&& current_head
->parents
->next
);
534 static const char sign_off_header
[] = "Signed-off-by: ";
536 static void determine_author_info(struct strbuf
*author_ident
)
538 char *name
, *email
, *date
;
540 name
= getenv("GIT_AUTHOR_NAME");
541 email
= getenv("GIT_AUTHOR_EMAIL");
542 date
= getenv("GIT_AUTHOR_DATE");
544 if (author_message
) {
545 const char *a
, *lb
, *rb
, *eol
;
547 a
= strstr(author_message_buffer
, "\nauthor ");
549 die(_("invalid commit: %s"), author_message
);
551 lb
= strchrnul(a
+ strlen("\nauthor "), '<');
552 rb
= strchrnul(lb
, '>');
553 eol
= strchrnul(rb
, '\n');
554 if (!*lb
|| !*rb
|| !*eol
)
555 die(_("invalid commit: %s"), author_message
);
557 if (lb
== a
+ strlen("\nauthor "))
558 /* \nauthor <foo@example.com> */
559 name
= xcalloc(1, 1);
561 name
= xmemdupz(a
+ strlen("\nauthor "),
563 (a
+ strlen("\nauthor "))));
564 email
= xmemdupz(lb
+ strlen("<"), rb
- (lb
+ strlen("<")));
565 date
= xmemdupz(rb
+ strlen("> "), eol
- (rb
+ strlen("> ")));
569 const char *lb
= strstr(force_author
, " <");
570 const char *rb
= strchr(force_author
, '>');
573 die(_("malformed --author parameter"));
574 name
= xstrndup(force_author
, lb
- force_author
);
575 email
= xstrndup(lb
+ 2, rb
- (lb
+ 2));
580 strbuf_addstr(author_ident
, fmt_ident(name
, email
, date
,
581 IDENT_ERROR_ON_NO_NAME
));
584 static int ends_rfc2822_footer(struct strbuf
*sb
)
591 const char *buf
= sb
->buf
;
593 for (i
= len
- 1; i
> 0; i
--) {
594 if (hit
&& buf
[i
] == '\n')
596 hit
= (buf
[i
] == '\n');
599 while (i
< len
- 1 && buf
[i
] == '\n')
602 for (; i
< len
; i
= k
) {
603 for (k
= i
; k
< len
&& buf
[k
] != '\n'; k
++)
607 if ((buf
[k
] == ' ' || buf
[k
] == '\t') && !first
)
612 for (j
= 0; i
+ j
< len
; j
++) {
625 static char *cut_ident_timestamp_part(char *string
)
627 char *ket
= strrchr(string
, '>');
628 if (!ket
|| ket
[1] != ' ')
629 die(_("Malformed ident string: '%s'"), string
);
634 static int prepare_to_commit(const char *index_file
, const char *prefix
,
635 struct commit
*current_head
,
637 struct strbuf
*author_ident
)
640 struct strbuf committer_ident
= STRBUF_INIT
;
641 int commitable
, saved_color_setting
;
642 struct strbuf sb
= STRBUF_INIT
;
644 const char *hook_arg1
= NULL
;
645 const char *hook_arg2
= NULL
;
647 int clean_message_contents
= (cleanup_mode
!= CLEANUP_NONE
);
649 if (!no_verify
&& run_hook(index_file
, "pre-commit", NULL
))
652 if (squash_message
) {
654 * Insert the proper subject line before other commit
655 * message options add their content.
657 if (use_message
&& !strcmp(use_message
, squash_message
))
658 strbuf_addstr(&sb
, "squash! ");
660 struct pretty_print_context ctx
= {0};
662 c
= lookup_commit_reference_by_name(squash_message
);
664 die(_("could not lookup commit %s"), squash_message
);
665 ctx
.output_encoding
= get_commit_output_encoding();
666 format_commit_message(c
, "squash! %s\n\n", &sb
,
672 strbuf_addbuf(&sb
, &message
);
673 hook_arg1
= "message";
674 } else if (logfile
&& !strcmp(logfile
, "-")) {
676 fprintf(stderr
, _("(reading log message from standard input)\n"));
677 if (strbuf_read(&sb
, 0, 0) < 0)
678 die_errno(_("could not read log from standard input"));
679 hook_arg1
= "message";
680 } else if (logfile
) {
681 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
682 die_errno(_("could not read log file '%s'"),
684 hook_arg1
= "message";
685 } else if (use_message
) {
686 buffer
= strstr(use_message_buffer
, "\n\n");
687 if (!buffer
|| buffer
[2] == '\0')
688 die(_("commit has empty message"));
689 strbuf_add(&sb
, buffer
+ 2, strlen(buffer
+ 2));
690 hook_arg1
= "commit";
691 hook_arg2
= use_message
;
692 } else if (fixup_message
) {
693 struct pretty_print_context ctx
= {0};
694 struct commit
*commit
;
695 commit
= lookup_commit_reference_by_name(fixup_message
);
697 die(_("could not lookup commit %s"), fixup_message
);
698 ctx
.output_encoding
= get_commit_output_encoding();
699 format_commit_message(commit
, "fixup! %s\n\n",
701 hook_arg1
= "message";
702 } else if (!stat(git_path("MERGE_MSG"), &statbuf
)) {
703 if (strbuf_read_file(&sb
, git_path("MERGE_MSG"), 0) < 0)
704 die_errno(_("could not read MERGE_MSG"));
706 } else if (!stat(git_path("SQUASH_MSG"), &statbuf
)) {
707 if (strbuf_read_file(&sb
, git_path("SQUASH_MSG"), 0) < 0)
708 die_errno(_("could not read SQUASH_MSG"));
709 hook_arg1
= "squash";
710 } else if (template_file
) {
711 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
712 die_errno(_("could not read '%s'"), template_file
);
713 hook_arg1
= "template";
714 clean_message_contents
= 0;
718 * The remaining cases don't modify the template message, but
719 * just set the argument(s) to the prepare-commit-msg hook.
721 else if (whence
== FROM_MERGE
)
723 else if (whence
== FROM_CHERRY_PICK
) {
724 hook_arg1
= "commit";
725 hook_arg2
= "CHERRY_PICK_HEAD";
728 if (squash_message
) {
730 * If squash_commit was used for the commit subject,
731 * then we're possibly hijacking other commit log options.
732 * Reset the hook args to tell the real story.
734 hook_arg1
= "message";
738 s
->fp
= fopen(git_path(commit_editmsg
), "w");
740 die_errno(_("could not open '%s'"), git_path(commit_editmsg
));
742 if (clean_message_contents
)
746 struct strbuf sob
= STRBUF_INIT
;
749 strbuf_addstr(&sob
, sign_off_header
);
750 strbuf_addstr(&sob
, fmt_name(getenv("GIT_COMMITTER_NAME"),
751 getenv("GIT_COMMITTER_EMAIL")));
752 strbuf_addch(&sob
, '\n');
753 for (i
= sb
.len
- 1; i
> 0 && sb
.buf
[i
- 1] != '\n'; i
--)
755 if (prefixcmp(sb
.buf
+ i
, sob
.buf
)) {
756 if (!i
|| !ends_rfc2822_footer(&sb
))
757 strbuf_addch(&sb
, '\n');
758 strbuf_addbuf(&sb
, &sob
);
760 strbuf_release(&sob
);
763 if (fwrite(sb
.buf
, 1, sb
.len
, s
->fp
) < sb
.len
)
764 die_errno(_("could not write commit template"));
768 /* This checks and barfs if author is badly specified */
769 determine_author_info(author_ident
);
771 /* This checks if committer ident is explicitly given */
772 strbuf_addstr(&committer_ident
, git_committer_info(0));
773 if (use_editor
&& include_status
) {
774 char *ai_tmp
, *ci_tmp
;
775 if (whence
!= FROM_COMMIT
)
776 status_printf_ln(s
, GIT_COLOR_NORMAL
,
778 "It looks like you may be committing a %s.\n"
779 "If this is not correct, please remove the file\n"
784 git_path(whence
== FROM_MERGE
786 : "CHERRY_PICK_HEAD"));
788 fprintf(s
->fp
, "\n");
789 status_printf(s
, GIT_COLOR_NORMAL
,
790 _("Please enter the commit message for your changes."));
791 if (cleanup_mode
== CLEANUP_ALL
)
792 status_printf_more(s
, GIT_COLOR_NORMAL
,
793 _(" Lines starting\n"
794 "with '#' will be ignored, and an empty"
795 " message aborts the commit.\n"));
796 else /* CLEANUP_SPACE, that is. */
797 status_printf_more(s
, GIT_COLOR_NORMAL
,
798 _(" Lines starting\n"
799 "with '#' will be kept; you may remove them"
800 " yourself if you want to.\n"
801 "An empty message aborts the commit.\n"));
802 if (only_include_assumed
)
803 status_printf_ln(s
, GIT_COLOR_NORMAL
,
804 "%s", only_include_assumed
);
806 ai_tmp
= cut_ident_timestamp_part(author_ident
->buf
);
807 ci_tmp
= cut_ident_timestamp_part(committer_ident
.buf
);
808 if (strcmp(author_ident
->buf
, committer_ident
.buf
))
809 status_printf_ln(s
, GIT_COLOR_NORMAL
,
812 ident_shown
++ ? "" : "\n",
815 if (!user_ident_sufficiently_given())
816 status_printf_ln(s
, GIT_COLOR_NORMAL
,
819 ident_shown
++ ? "" : "\n",
820 committer_ident
.buf
);
823 status_printf_ln(s
, GIT_COLOR_NORMAL
, "");
825 saved_color_setting
= s
->use_color
;
827 commitable
= run_status(s
->fp
, index_file
, prefix
, 1, s
);
828 s
->use_color
= saved_color_setting
;
833 unsigned char sha1
[20];
834 const char *parent
= "HEAD";
836 if (!active_nr
&& read_cache() < 0)
837 die(_("Cannot read index"));
842 if (get_sha1(parent
, sha1
))
843 commitable
= !!active_nr
;
845 commitable
= index_differs_from(parent
, 0);
847 strbuf_release(&committer_ident
);
852 * Reject an attempt to record a non-merge empty commit without
853 * explicit --allow-empty. In the cherry-pick case, it may be
854 * empty due to conflict resolution, which the user should okay.
856 if (!commitable
&& whence
!= FROM_MERGE
&& !allow_empty
&&
857 !(amend
&& is_a_merge(current_head
))) {
858 run_status(stdout
, index_file
, prefix
, 0, s
);
860 fputs(_(empty_amend_advice
), stderr
);
861 else if (whence
== FROM_CHERRY_PICK
)
862 fputs(_(empty_cherry_pick_advice
), stderr
);
867 * Re-read the index as pre-commit hook could have updated it,
868 * and write it out as a tree. We must do this before we invoke
869 * the editor and after we invoke run_status above.
872 read_cache_from(index_file
);
873 if (update_main_cache_tree(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
)
1029 use_editor
= edit_flag
;
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];
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
);
1312 head
= resolve_ref_unsafe("HEAD", junk_sha1
, 0, NULL
);
1314 !prefixcmp(head
, "refs/heads/") ?
1316 !strcmp(head
, "HEAD") ?
1317 _("detached HEAD") :
1319 initial_commit
? _(" (root-commit)") : "");
1321 if (!log_tree_commit(&rev
, commit
)) {
1322 rev
.always_show_header
= 1;
1323 rev
.use_terminator
= 1;
1324 log_tree_commit(&rev
, commit
);
1327 strbuf_release(&format
);
1330 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1332 struct wt_status
*s
= cb
;
1335 if (!strcmp(k
, "commit.template"))
1336 return git_config_pathname(&template_file
, k
, v
);
1337 if (!strcmp(k
, "commit.status")) {
1338 include_status
= git_config_bool(k
, v
);
1342 status
= git_gpg_config(k
, v
, NULL
);
1345 return git_status_config(k
, v
, s
);
1348 static const char post_rewrite_hook
[] = "hooks/post-rewrite";
1350 static int run_rewrite_hook(const unsigned char *oldsha1
,
1351 const unsigned char *newsha1
)
1353 /* oldsha1 SP newsha1 LF NUL */
1354 static char buf
[2*40 + 3];
1355 struct child_process proc
;
1356 const char *argv
[3];
1360 if (access(git_path(post_rewrite_hook
), X_OK
) < 0)
1363 argv
[0] = git_path(post_rewrite_hook
);
1367 memset(&proc
, 0, sizeof(proc
));
1370 proc
.stdout_to_stderr
= 1;
1372 code
= start_command(&proc
);
1375 n
= snprintf(buf
, sizeof(buf
), "%s %s\n",
1376 sha1_to_hex(oldsha1
), sha1_to_hex(newsha1
));
1377 write_in_full(proc
.in
, buf
, n
);
1379 return finish_command(&proc
);
1382 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1384 struct strbuf sb
= STRBUF_INIT
;
1385 struct strbuf author_ident
= STRBUF_INIT
;
1386 const char *index_file
, *reflog_msg
;
1388 unsigned char sha1
[20];
1389 struct ref_lock
*ref_lock
;
1390 struct commit_list
*parents
= NULL
, **pptr
= &parents
;
1391 struct stat statbuf
;
1392 int allow_fast_forward
= 1;
1394 struct commit
*current_head
= NULL
;
1395 struct commit_extra_header
*extra
= NULL
;
1397 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1398 usage_with_options(builtin_commit_usage
, builtin_commit_options
);
1400 wt_status_prepare(&s
);
1401 git_config(git_commit_config
, &s
);
1402 determine_whence(&s
);
1404 if (get_sha1("HEAD", sha1
))
1405 current_head
= NULL
;
1407 current_head
= lookup_commit_or_die(sha1
, "HEAD");
1408 if (!current_head
|| parse_commit(current_head
))
1409 die(_("could not parse HEAD commit"));
1411 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_usage
,
1412 prefix
, current_head
, &s
);
1414 return dry_run_commit(argc
, argv
, prefix
, current_head
, &s
);
1415 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 0);
1417 /* Set up everything for writing the commit object. This includes
1418 running hooks, writing the trees, and interacting with the user. */
1419 if (!prepare_to_commit(index_file
, prefix
,
1420 current_head
, &s
, &author_ident
)) {
1421 rollback_index_files();
1425 /* Determine parents */
1426 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1427 if (!current_head
) {
1429 reflog_msg
= "commit (initial)";
1431 struct commit_list
*c
;
1434 reflog_msg
= "commit (amend)";
1435 for (c
= current_head
->parents
; c
; c
= c
->next
)
1436 pptr
= &commit_list_insert(c
->item
, pptr
)->next
;
1437 } else if (whence
== FROM_MERGE
) {
1438 struct strbuf m
= STRBUF_INIT
;
1442 reflog_msg
= "commit (merge)";
1443 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1444 fp
= fopen(git_path("MERGE_HEAD"), "r");
1446 die_errno(_("could not open '%s' for reading"),
1447 git_path("MERGE_HEAD"));
1448 while (strbuf_getline(&m
, fp
, '\n') != EOF
) {
1449 struct commit
*parent
;
1451 parent
= get_merge_parent(m
.buf
);
1453 die(_("Corrupt MERGE_HEAD file (%s)"), m
.buf
);
1454 pptr
= &commit_list_insert(parent
, pptr
)->next
;
1458 if (!stat(git_path("MERGE_MODE"), &statbuf
)) {
1459 if (strbuf_read_file(&sb
, git_path("MERGE_MODE"), 0) < 0)
1460 die_errno(_("could not read MERGE_MODE"));
1461 if (!strcmp(sb
.buf
, "no-ff"))
1462 allow_fast_forward
= 0;
1464 if (allow_fast_forward
)
1465 parents
= reduce_heads(parents
);
1468 reflog_msg
= (whence
== FROM_CHERRY_PICK
)
1469 ? "commit (cherry-pick)"
1471 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1474 /* Finally, get the commit message */
1476 if (strbuf_read_file(&sb
, git_path(commit_editmsg
), 0) < 0) {
1477 int saved_errno
= errno
;
1478 rollback_index_files();
1479 die(_("could not read commit message: %s"), strerror(saved_errno
));
1482 /* Truncate the message just before the diff, if any. */
1484 p
= strstr(sb
.buf
, "\ndiff --git ");
1486 strbuf_setlen(&sb
, p
- sb
.buf
+ 1);
1489 if (cleanup_mode
!= CLEANUP_NONE
)
1490 stripspace(&sb
, cleanup_mode
== CLEANUP_ALL
);
1491 if (message_is_empty(&sb
) && !allow_empty_message
) {
1492 rollback_index_files();
1493 fprintf(stderr
, _("Aborting commit due to empty commit message.\n"));
1498 const char *exclude_gpgsig
[2] = { "gpgsig", NULL
};
1499 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1501 struct commit_extra_header
**tail
= &extra
;
1502 append_merge_tag_headers(parents
, &tail
);
1505 if (commit_tree_extended(&sb
, active_cache_tree
->sha1
, parents
, sha1
,
1506 author_ident
.buf
, sign_commit
, extra
)) {
1507 rollback_index_files();
1508 die(_("failed to write commit object"));
1510 strbuf_release(&author_ident
);
1511 free_commit_extra_headers(extra
);
1513 ref_lock
= lock_any_ref_for_update("HEAD",
1516 : current_head
->object
.sha1
,
1519 nl
= strchr(sb
.buf
, '\n');
1521 strbuf_setlen(&sb
, nl
+ 1 - sb
.buf
);
1523 strbuf_addch(&sb
, '\n');
1524 strbuf_insert(&sb
, 0, reflog_msg
, strlen(reflog_msg
));
1525 strbuf_insert(&sb
, strlen(reflog_msg
), ": ", 2);
1528 rollback_index_files();
1529 die(_("cannot lock HEAD ref"));
1531 if (write_ref_sha1(ref_lock
, sha1
, sb
.buf
) < 0) {
1532 rollback_index_files();
1533 die(_("cannot update HEAD ref"));
1536 unlink(git_path("CHERRY_PICK_HEAD"));
1537 unlink(git_path("REVERT_HEAD"));
1538 unlink(git_path("MERGE_HEAD"));
1539 unlink(git_path("MERGE_MSG"));
1540 unlink(git_path("MERGE_MODE"));
1541 unlink(git_path("SQUASH_MSG"));
1543 if (commit_index_files())
1544 die (_("Repository has been updated, but unable to write\n"
1545 "new_index file. Check that disk is not full or quota is\n"
1546 "not exceeded, and then \"git reset HEAD\" to recover."));
1549 run_hook(get_index_file(), "post-commit", NULL
);
1550 if (amend
&& !no_post_rewrite
) {
1551 struct notes_rewrite_cfg
*cfg
;
1552 cfg
= init_copy_notes_for_rewrite("amend");
1554 /* we are amending, so current_head is not NULL */
1555 copy_note_for_rewrite(cfg
, current_head
->object
.sha1
, sha1
);
1556 finish_copy_notes_for_rewrite(cfg
);
1558 run_rewrite_hook(current_head
->object
.sha1
, sha1
);
1561 print_summary(prefix
, sha1
, !current_head
);