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"
32 static const char * const builtin_commit_usage
[] = {
33 "git commit [options] [--] <filepattern>...",
37 static const char * const builtin_status_usage
[] = {
38 "git status [options] [--] <filepattern>...",
42 static const char implicit_ident_advice
[] =
43 N_("Your name and email address were configured automatically based\n"
44 "on your username and hostname. Please check that they are accurate.\n"
45 "You can suppress this message by setting them explicitly:\n"
47 " git config --global user.name \"Your Name\"\n"
48 " git config --global user.email you@example.com\n"
50 "After doing this, you may fix the identity used for this commit with:\n"
52 " git commit --amend --reset-author\n");
54 static const char empty_amend_advice
[] =
55 N_("You asked to amend the most recent commit, but doing so would make\n"
56 "it empty. You can repeat your command with --allow-empty, or you can\n"
57 "remove the commit entirely with \"git reset HEAD^\".\n");
59 static const char empty_cherry_pick_advice
[] =
60 N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
61 "If you wish to commit it anyway, use:\n"
63 " git commit --allow-empty\n"
65 "Otherwise, please use 'git reset'\n");
67 static const char *use_message_buffer
;
68 static const char commit_editmsg
[] = "COMMIT_EDITMSG";
69 static struct lock_file index_lock
; /* real index */
70 static struct lock_file false_lock
; /* used only for partial commits */
77 static const char *logfile
, *force_author
;
78 static const char *template_file
;
80 * The _message variables are commit names from which to take
81 * the commit message and/or authorship.
83 static const char *author_message
, *author_message_buffer
;
84 static char *edit_message
, *use_message
;
85 static char *fixup_message
, *squash_message
;
86 static int all
, also
, interactive
, patch_interactive
, only
, amend
, signoff
;
87 static int edit_flag
= -1; /* unspecified */
88 static int quiet
, verbose
, no_verify
, allow_empty
, dry_run
, renew_authorship
;
89 static int no_post_rewrite
, allow_empty_message
;
90 static char *untracked_files_arg
, *force_date
, *ignore_submodule_arg
;
91 static char *sign_commit
;
92 static unsigned int colopts
;
95 * The default commit message cleanup mode will remove the lines
96 * beginning with # (shell comments) and leading and trailing
97 * whitespaces (empty lines or containing only whitespaces)
98 * if editor is used, and only the whitespaces if the message
99 * is specified explicitly.
106 static char *cleanup_arg
;
108 static enum commit_whence whence
;
109 static int use_editor
= 1, include_status
= 1;
110 static int show_ignored_in_status
;
111 static const char *only_include_assumed
;
112 static struct strbuf message
= STRBUF_INIT
;
114 static int null_termination
;
118 STATUS_FORMAT_PORCELAIN
119 } status_format
= STATUS_FORMAT_LONG
;
120 static int status_show_branch
;
122 static int opt_parse_m(const struct option
*opt
, const char *arg
, int unset
)
124 struct strbuf
*buf
= opt
->value
;
126 strbuf_setlen(buf
, 0);
128 strbuf_addstr(buf
, arg
);
129 strbuf_addstr(buf
, "\n\n");
134 static struct option builtin_commit_options
[] = {
135 OPT__QUIET(&quiet
, "suppress summary after successful commit"),
136 OPT__VERBOSE(&verbose
, "show diff in commit message template"),
138 OPT_GROUP("Commit message options"),
139 OPT_FILENAME('F', "file", &logfile
, "read message from file"),
140 OPT_STRING(0, "author", &force_author
, "author", "override author for commit"),
141 OPT_STRING(0, "date", &force_date
, "date", "override date for commit"),
142 OPT_CALLBACK('m', "message", &message
, "message", "commit message", opt_parse_m
),
143 OPT_STRING('c', "reedit-message", &edit_message
, "commit", "reuse and edit message from specified commit"),
144 OPT_STRING('C', "reuse-message", &use_message
, "commit", "reuse message from specified commit"),
145 OPT_STRING(0, "fixup", &fixup_message
, "commit", "use autosquash formatted message to fixup specified commit"),
146 OPT_STRING(0, "squash", &squash_message
, "commit", "use autosquash formatted message to squash specified commit"),
147 OPT_BOOLEAN(0, "reset-author", &renew_authorship
, "the commit is authored by me now (used with -C/-c/--amend)"),
148 OPT_BOOLEAN('s', "signoff", &signoff
, "add Signed-off-by:"),
149 OPT_FILENAME('t', "template", &template_file
, "use specified template file"),
150 OPT_BOOL('e', "edit", &edit_flag
, "force edit of commit"),
151 OPT_STRING(0, "cleanup", &cleanup_arg
, "default", "how to strip spaces and #comments from message"),
152 OPT_BOOLEAN(0, "status", &include_status
, "include status in commit message template"),
153 { OPTION_STRING
, 'S', "gpg-sign", &sign_commit
, "key id",
154 "GPG sign commit", PARSE_OPT_OPTARG
, NULL
, (intptr_t) "" },
155 /* end commit message options */
157 OPT_GROUP("Commit contents options"),
158 OPT_BOOLEAN('a', "all", &all
, "commit all changed files"),
159 OPT_BOOLEAN('i', "include", &also
, "add specified files to index for commit"),
160 OPT_BOOLEAN(0, "interactive", &interactive
, "interactively add files"),
161 OPT_BOOLEAN('p', "patch", &patch_interactive
, "interactively add changes"),
162 OPT_BOOLEAN('o', "only", &only
, "commit only specified files"),
163 OPT_BOOLEAN('n', "no-verify", &no_verify
, "bypass pre-commit hook"),
164 OPT_BOOLEAN(0, "dry-run", &dry_run
, "show what would be committed"),
165 OPT_SET_INT(0, "short", &status_format
, "show status concisely",
166 STATUS_FORMAT_SHORT
),
167 OPT_BOOLEAN(0, "branch", &status_show_branch
, "show branch information"),
168 OPT_SET_INT(0, "porcelain", &status_format
,
169 "machine-readable output", STATUS_FORMAT_PORCELAIN
),
170 OPT_BOOLEAN('z', "null", &null_termination
,
171 "terminate entries with NUL"),
172 OPT_BOOLEAN(0, "amend", &amend
, "amend previous commit"),
173 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite
, "bypass post-rewrite hook"),
174 { 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" },
175 /* end commit contents options */
177 { OPTION_BOOLEAN
, 0, "allow-empty", &allow_empty
, NULL
,
178 "ok to record an empty change",
179 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
180 { OPTION_BOOLEAN
, 0, "allow-empty-message", &allow_empty_message
, NULL
,
181 "ok to record a change with an empty message",
182 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
187 static void determine_whence(struct wt_status
*s
)
189 if (file_exists(git_path("MERGE_HEAD")))
191 else if (file_exists(git_path("CHERRY_PICK_HEAD")))
192 whence
= FROM_CHERRY_PICK
;
194 whence
= FROM_COMMIT
;
199 static const char *whence_s(void)
209 case FROM_CHERRY_PICK
:
210 s
= _("cherry-pick");
217 static void rollback_index_files(void)
219 switch (commit_style
) {
221 break; /* nothing to do */
223 rollback_lock_file(&index_lock
);
226 rollback_lock_file(&index_lock
);
227 rollback_lock_file(&false_lock
);
232 static int commit_index_files(void)
236 switch (commit_style
) {
238 break; /* nothing to do */
240 err
= commit_lock_file(&index_lock
);
243 err
= commit_lock_file(&index_lock
);
244 rollback_lock_file(&false_lock
);
252 * Take a union of paths in the index and the named tree (typically, "HEAD"),
253 * and return the paths that match the given pattern in list.
255 static int list_paths(struct string_list
*list
, const char *with_tree
,
256 const char *prefix
, const char **pattern
)
261 for (i
= 0; pattern
[i
]; i
++)
266 char *max_prefix
= common_prefix(pattern
);
267 overlay_tree_on_cache(with_tree
, max_prefix
? max_prefix
: prefix
);
271 for (i
= 0; i
< active_nr
; i
++) {
272 struct cache_entry
*ce
= active_cache
[i
];
273 struct string_list_item
*item
;
275 if (ce
->ce_flags
& CE_UPDATE
)
277 if (!match_pathspec(pattern
, ce
->name
, ce_namelen(ce
), 0, m
))
279 item
= string_list_insert(list
, ce
->name
);
280 if (ce_skip_worktree(ce
))
281 item
->util
= item
; /* better a valid pointer than a fake one */
284 return report_path_error(m
, pattern
, prefix
);
287 static void add_remove_files(struct string_list
*list
)
290 for (i
= 0; i
< list
->nr
; i
++) {
292 struct string_list_item
*p
= &(list
->items
[i
]);
294 /* p->util is skip-worktree */
298 if (!lstat(p
->string
, &st
)) {
299 if (add_to_cache(p
->string
, &st
, 0))
300 die(_("updating files failed"));
302 remove_file_from_cache(p
->string
);
306 static void create_base_index(const struct commit
*current_head
)
309 struct unpack_trees_options opts
;
317 memset(&opts
, 0, sizeof(opts
));
321 opts
.src_index
= &the_index
;
322 opts
.dst_index
= &the_index
;
324 opts
.fn
= oneway_merge
;
325 tree
= parse_tree_indirect(current_head
->object
.sha1
);
327 die(_("failed to unpack HEAD tree object"));
329 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
330 if (unpack_trees(1, &t
, &opts
))
331 exit(128); /* We've already reported the error, finish dying */
334 static void refresh_cache_or_die(int refresh_flags
)
337 * refresh_flags contains REFRESH_QUIET, so the only errors
338 * are for unmerged entries.
340 if (refresh_cache(refresh_flags
| REFRESH_IN_PORCELAIN
))
341 die_resolve_conflict("commit");
344 static char *prepare_index(int argc
, const char **argv
, const char *prefix
,
345 const struct commit
*current_head
, int is_status
)
348 struct string_list partial
;
349 const char **pathspec
= NULL
;
350 char *old_index_env
= NULL
;
351 int refresh_flags
= REFRESH_QUIET
;
354 refresh_flags
|= REFRESH_UNMERGED
;
357 pathspec
= get_pathspec(prefix
, argv
);
359 if (read_cache_preload(pathspec
) < 0)
360 die(_("index file corrupt"));
363 fd
= hold_locked_index(&index_lock
, 1);
365 refresh_cache_or_die(refresh_flags
);
367 if (write_cache(fd
, active_cache
, active_nr
) ||
368 close_lock_file(&index_lock
))
369 die(_("unable to create temporary index"));
371 old_index_env
= getenv(INDEX_ENVIRONMENT
);
372 setenv(INDEX_ENVIRONMENT
, index_lock
.filename
, 1);
374 if (interactive_add(argc
, argv
, prefix
, patch_interactive
) != 0)
375 die(_("interactive add failed"));
377 if (old_index_env
&& *old_index_env
)
378 setenv(INDEX_ENVIRONMENT
, old_index_env
, 1);
380 unsetenv(INDEX_ENVIRONMENT
);
383 read_cache_from(index_lock
.filename
);
385 commit_style
= COMMIT_NORMAL
;
386 return index_lock
.filename
;
390 * Non partial, non as-is commit.
392 * (1) get the real index;
393 * (2) update the_index as necessary;
394 * (3) write the_index out to the real index (still locked);
395 * (4) return the name of the locked index file.
397 * The caller should run hooks on the locked real index, and
398 * (A) if all goes well, commit the real index;
399 * (B) on failure, rollback the real index.
401 if (all
|| (also
&& pathspec
&& *pathspec
)) {
402 fd
= hold_locked_index(&index_lock
, 1);
403 add_files_to_cache(also
? prefix
: NULL
, pathspec
, 0);
404 refresh_cache_or_die(refresh_flags
);
405 update_main_cache_tree(WRITE_TREE_SILENT
);
406 if (write_cache(fd
, active_cache
, active_nr
) ||
407 close_lock_file(&index_lock
))
408 die(_("unable to write new_index file"));
409 commit_style
= COMMIT_NORMAL
;
410 return index_lock
.filename
;
416 * (1) return the name of the real index file.
418 * The caller should run hooks on the real index,
419 * and create commit from the_index.
420 * We still need to refresh the index here.
422 if (!pathspec
|| !*pathspec
) {
423 fd
= hold_locked_index(&index_lock
, 1);
424 refresh_cache_or_die(refresh_flags
);
425 if (active_cache_changed
) {
426 update_main_cache_tree(WRITE_TREE_SILENT
);
427 if (write_cache(fd
, active_cache
, active_nr
) ||
428 commit_locked_index(&index_lock
))
429 die(_("unable to write new_index file"));
431 rollback_lock_file(&index_lock
);
433 commit_style
= COMMIT_AS_IS
;
434 return get_index_file();
440 * (0) find the set of affected paths;
441 * (1) get lock on the real index file;
442 * (2) update the_index with the given paths;
443 * (3) write the_index out to the real index (still locked);
444 * (4) get lock on the false index file;
445 * (5) reset the_index from HEAD;
446 * (6) update the_index the same way as (2);
447 * (7) write the_index out to the false index file;
448 * (8) return the name of the false index file (still locked);
450 * The caller should run hooks on the locked false index, and
451 * create commit from it. Then
452 * (A) if all goes well, commit the real index;
453 * (B) on failure, rollback the real index;
454 * In either case, rollback the false index.
456 commit_style
= COMMIT_PARTIAL
;
458 if (whence
!= FROM_COMMIT
)
459 die(_("cannot do a partial commit during a %s."), whence_s());
461 memset(&partial
, 0, sizeof(partial
));
462 partial
.strdup_strings
= 1;
463 if (list_paths(&partial
, !current_head
? NULL
: "HEAD", prefix
, pathspec
))
467 if (read_cache() < 0)
468 die(_("cannot read the index"));
470 fd
= hold_locked_index(&index_lock
, 1);
471 add_remove_files(&partial
);
472 refresh_cache(REFRESH_QUIET
);
473 if (write_cache(fd
, active_cache
, active_nr
) ||
474 close_lock_file(&index_lock
))
475 die(_("unable to write new_index file"));
477 fd
= hold_lock_file_for_update(&false_lock
,
478 git_path("next-index-%"PRIuMAX
,
479 (uintmax_t) getpid()),
482 create_base_index(current_head
);
483 add_remove_files(&partial
);
484 refresh_cache(REFRESH_QUIET
);
486 if (write_cache(fd
, active_cache
, active_nr
) ||
487 close_lock_file(&false_lock
))
488 die(_("unable to write temporary index file"));
491 read_cache_from(false_lock
.filename
);
493 return false_lock
.filename
;
496 static int run_status(FILE *fp
, const char *index_file
, const char *prefix
, int nowarn
,
499 unsigned char sha1
[20];
501 if (s
->relative_paths
)
506 s
->reference
= "HEAD^1";
508 s
->verbose
= verbose
;
509 s
->index_file
= index_file
;
512 s
->is_initial
= get_sha1(s
->reference
, sha1
) ? 1 : 0;
514 wt_status_collect(s
);
516 switch (status_format
) {
517 case STATUS_FORMAT_SHORT
:
518 wt_shortstatus_print(s
, null_termination
, status_show_branch
);
520 case STATUS_FORMAT_PORCELAIN
:
521 wt_porcelain_print(s
, null_termination
);
523 case STATUS_FORMAT_LONG
:
528 return s
->commitable
;
531 static int is_a_merge(const struct commit
*current_head
)
533 return !!(current_head
->parents
&& current_head
->parents
->next
);
536 static const char sign_off_header
[] = "Signed-off-by: ";
538 static void determine_author_info(struct strbuf
*author_ident
)
540 char *name
, *email
, *date
;
542 name
= getenv("GIT_AUTHOR_NAME");
543 email
= getenv("GIT_AUTHOR_EMAIL");
544 date
= getenv("GIT_AUTHOR_DATE");
546 if (author_message
) {
547 const char *a
, *lb
, *rb
, *eol
;
550 a
= strstr(author_message_buffer
, "\nauthor ");
552 die(_("invalid commit: %s"), author_message
);
554 lb
= strchrnul(a
+ strlen("\nauthor "), '<');
555 rb
= strchrnul(lb
, '>');
556 eol
= strchrnul(rb
, '\n');
557 if (!*lb
|| !*rb
|| !*eol
)
558 die(_("invalid commit: %s"), author_message
);
560 if (lb
== a
+ strlen("\nauthor "))
561 /* \nauthor <foo@example.com> */
562 name
= xcalloc(1, 1);
564 name
= xmemdupz(a
+ strlen("\nauthor "),
566 (a
+ strlen("\nauthor "))));
567 email
= xmemdupz(lb
+ strlen("<"), rb
- (lb
+ strlen("<")));
568 date
= xmemdupz(rb
+ strlen("> "), eol
- (rb
+ strlen("> ")));
569 len
= eol
- (rb
+ strlen("> "));
570 date
= xmalloc(len
+ 2);
572 memcpy(date
+ 1, rb
+ strlen("> "), len
);
573 date
[len
+ 1] = '\0';
577 const char *lb
= strstr(force_author
, " <");
578 const char *rb
= strchr(force_author
, '>');
581 die(_("malformed --author parameter"));
582 name
= xstrndup(force_author
, lb
- force_author
);
583 email
= xstrndup(lb
+ 2, rb
- (lb
+ 2));
588 strbuf_addstr(author_ident
, fmt_ident(name
, email
, date
,
589 IDENT_ERROR_ON_NO_NAME
));
592 static int ends_rfc2822_footer(struct strbuf
*sb
)
599 const char *buf
= sb
->buf
;
601 for (i
= len
- 1; i
> 0; i
--) {
602 if (hit
&& buf
[i
] == '\n')
604 hit
= (buf
[i
] == '\n');
607 while (i
< len
- 1 && buf
[i
] == '\n')
610 for (; i
< len
; i
= k
) {
611 for (k
= i
; k
< len
&& buf
[k
] != '\n'; k
++)
615 if ((buf
[k
] == ' ' || buf
[k
] == '\t') && !first
)
620 for (j
= 0; i
+ j
< len
; j
++) {
633 static char *cut_ident_timestamp_part(char *string
)
635 char *ket
= strrchr(string
, '>');
636 if (!ket
|| ket
[1] != ' ')
637 die(_("Malformed ident string: '%s'"), string
);
642 static int prepare_to_commit(const char *index_file
, const char *prefix
,
643 struct commit
*current_head
,
645 struct strbuf
*author_ident
)
648 struct strbuf committer_ident
= STRBUF_INIT
;
649 int commitable
, saved_color_setting
;
650 struct strbuf sb
= STRBUF_INIT
;
652 const char *hook_arg1
= NULL
;
653 const char *hook_arg2
= NULL
;
655 int clean_message_contents
= (cleanup_mode
!= CLEANUP_NONE
);
657 if (!no_verify
&& run_hook(index_file
, "pre-commit", NULL
))
660 if (squash_message
) {
662 * Insert the proper subject line before other commit
663 * message options add their content.
665 if (use_message
&& !strcmp(use_message
, squash_message
))
666 strbuf_addstr(&sb
, "squash! ");
668 struct pretty_print_context ctx
= {0};
670 c
= lookup_commit_reference_by_name(squash_message
);
672 die(_("could not lookup commit %s"), squash_message
);
673 ctx
.output_encoding
= get_commit_output_encoding();
674 format_commit_message(c
, "squash! %s\n\n", &sb
,
680 strbuf_addbuf(&sb
, &message
);
681 hook_arg1
= "message";
682 } else if (logfile
&& !strcmp(logfile
, "-")) {
684 fprintf(stderr
, _("(reading log message from standard input)\n"));
685 if (strbuf_read(&sb
, 0, 0) < 0)
686 die_errno(_("could not read log from standard input"));
687 hook_arg1
= "message";
688 } else if (logfile
) {
689 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
690 die_errno(_("could not read log file '%s'"),
692 hook_arg1
= "message";
693 } else if (use_message
) {
694 buffer
= strstr(use_message_buffer
, "\n\n");
695 if (!buffer
|| buffer
[2] == '\0')
696 die(_("commit has empty message"));
697 strbuf_add(&sb
, buffer
+ 2, strlen(buffer
+ 2));
698 hook_arg1
= "commit";
699 hook_arg2
= use_message
;
700 } else if (fixup_message
) {
701 struct pretty_print_context ctx
= {0};
702 struct commit
*commit
;
703 commit
= lookup_commit_reference_by_name(fixup_message
);
705 die(_("could not lookup commit %s"), fixup_message
);
706 ctx
.output_encoding
= get_commit_output_encoding();
707 format_commit_message(commit
, "fixup! %s\n\n",
709 hook_arg1
= "message";
710 } else if (!stat(git_path("MERGE_MSG"), &statbuf
)) {
711 if (strbuf_read_file(&sb
, git_path("MERGE_MSG"), 0) < 0)
712 die_errno(_("could not read MERGE_MSG"));
714 } else if (!stat(git_path("SQUASH_MSG"), &statbuf
)) {
715 if (strbuf_read_file(&sb
, git_path("SQUASH_MSG"), 0) < 0)
716 die_errno(_("could not read SQUASH_MSG"));
717 hook_arg1
= "squash";
718 } else if (template_file
) {
719 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
720 die_errno(_("could not read '%s'"), template_file
);
721 hook_arg1
= "template";
722 clean_message_contents
= 0;
726 * The remaining cases don't modify the template message, but
727 * just set the argument(s) to the prepare-commit-msg hook.
729 else if (whence
== FROM_MERGE
)
731 else if (whence
== FROM_CHERRY_PICK
) {
732 hook_arg1
= "commit";
733 hook_arg2
= "CHERRY_PICK_HEAD";
736 if (squash_message
) {
738 * If squash_commit was used for the commit subject,
739 * then we're possibly hijacking other commit log options.
740 * Reset the hook args to tell the real story.
742 hook_arg1
= "message";
746 s
->fp
= fopen(git_path(commit_editmsg
), "w");
748 die_errno(_("could not open '%s'"), git_path(commit_editmsg
));
750 if (clean_message_contents
)
754 struct strbuf sob
= STRBUF_INIT
;
757 strbuf_addstr(&sob
, sign_off_header
);
758 strbuf_addstr(&sob
, fmt_name(getenv("GIT_COMMITTER_NAME"),
759 getenv("GIT_COMMITTER_EMAIL")));
760 strbuf_addch(&sob
, '\n');
761 for (i
= sb
.len
- 1; i
> 0 && sb
.buf
[i
- 1] != '\n'; i
--)
763 if (prefixcmp(sb
.buf
+ i
, sob
.buf
)) {
764 if (!i
|| !ends_rfc2822_footer(&sb
))
765 strbuf_addch(&sb
, '\n');
766 strbuf_addbuf(&sb
, &sob
);
768 strbuf_release(&sob
);
771 if (fwrite(sb
.buf
, 1, sb
.len
, s
->fp
) < sb
.len
)
772 die_errno(_("could not write commit template"));
776 /* This checks and barfs if author is badly specified */
777 determine_author_info(author_ident
);
779 /* This checks if committer ident is explicitly given */
780 strbuf_addstr(&committer_ident
, git_committer_info(0));
781 if (use_editor
&& include_status
) {
782 char *ai_tmp
, *ci_tmp
;
783 if (whence
!= FROM_COMMIT
)
784 status_printf_ln(s
, GIT_COLOR_NORMAL
,
786 "It looks like you may be committing a %s.\n"
787 "If this is not correct, please remove the file\n"
792 git_path(whence
== FROM_MERGE
794 : "CHERRY_PICK_HEAD"));
796 fprintf(s
->fp
, "\n");
797 status_printf(s
, GIT_COLOR_NORMAL
,
798 _("Please enter the commit message for your changes."));
799 if (cleanup_mode
== CLEANUP_ALL
)
800 status_printf_more(s
, GIT_COLOR_NORMAL
,
801 _(" Lines starting\n"
802 "with '#' will be ignored, and an empty"
803 " message aborts the commit.\n"));
804 else /* CLEANUP_SPACE, that is. */
805 status_printf_more(s
, GIT_COLOR_NORMAL
,
806 _(" Lines starting\n"
807 "with '#' will be kept; you may remove them"
808 " yourself if you want to.\n"
809 "An empty message aborts the commit.\n"));
810 if (only_include_assumed
)
811 status_printf_ln(s
, GIT_COLOR_NORMAL
,
812 "%s", only_include_assumed
);
814 ai_tmp
= cut_ident_timestamp_part(author_ident
->buf
);
815 ci_tmp
= cut_ident_timestamp_part(committer_ident
.buf
);
816 if (strcmp(author_ident
->buf
, committer_ident
.buf
))
817 status_printf_ln(s
, GIT_COLOR_NORMAL
,
820 ident_shown
++ ? "" : "\n",
823 if (!user_ident_sufficiently_given())
824 status_printf_ln(s
, GIT_COLOR_NORMAL
,
827 ident_shown
++ ? "" : "\n",
828 committer_ident
.buf
);
831 status_printf_ln(s
, GIT_COLOR_NORMAL
, "");
833 saved_color_setting
= s
->use_color
;
835 commitable
= run_status(s
->fp
, index_file
, prefix
, 1, s
);
836 s
->use_color
= saved_color_setting
;
841 unsigned char sha1
[20];
842 const char *parent
= "HEAD";
844 if (!active_nr
&& read_cache() < 0)
845 die(_("Cannot read index"));
850 if (get_sha1(parent
, sha1
))
851 commitable
= !!active_nr
;
853 commitable
= index_differs_from(parent
, 0);
855 strbuf_release(&committer_ident
);
860 * Reject an attempt to record a non-merge empty commit without
861 * explicit --allow-empty. In the cherry-pick case, it may be
862 * empty due to conflict resolution, which the user should okay.
864 if (!commitable
&& whence
!= FROM_MERGE
&& !allow_empty
&&
865 !(amend
&& is_a_merge(current_head
))) {
866 run_status(stdout
, index_file
, prefix
, 0, s
);
868 fputs(_(empty_amend_advice
), stderr
);
869 else if (whence
== FROM_CHERRY_PICK
)
870 fputs(_(empty_cherry_pick_advice
), stderr
);
875 * Re-read the index as pre-commit hook could have updated it,
876 * and write it out as a tree. We must do this before we invoke
877 * the editor and after we invoke run_status above.
880 read_cache_from(index_file
);
881 if (update_main_cache_tree(0)) {
882 error(_("Error building trees"));
886 if (run_hook(index_file
, "prepare-commit-msg",
887 git_path(commit_editmsg
), hook_arg1
, hook_arg2
, NULL
))
891 char index
[PATH_MAX
];
892 const char *env
[2] = { NULL
};
894 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
895 if (launch_editor(git_path(commit_editmsg
), NULL
, env
)) {
897 _("Please supply the message using either -m or -F option.\n"));
903 run_hook(index_file
, "commit-msg", git_path(commit_editmsg
), NULL
)) {
911 * Find out if the message in the strbuf contains only whitespace and
912 * Signed-off-by lines.
914 static int message_is_empty(struct strbuf
*sb
)
916 struct strbuf tmpl
= STRBUF_INIT
;
918 int eol
, i
, start
= 0;
920 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
923 /* See if the template is just a prefix of the message. */
924 if (template_file
&& strbuf_read_file(&tmpl
, template_file
, 0) > 0) {
925 stripspace(&tmpl
, cleanup_mode
== CLEANUP_ALL
);
926 if (start
+ tmpl
.len
<= sb
->len
&&
927 memcmp(tmpl
.buf
, sb
->buf
+ start
, tmpl
.len
) == 0)
930 strbuf_release(&tmpl
);
932 /* Check if the rest is just whitespace and Signed-of-by's. */
933 for (i
= start
; i
< sb
->len
; i
++) {
934 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
940 if (strlen(sign_off_header
) <= eol
- i
&&
941 !prefixcmp(sb
->buf
+ i
, sign_off_header
)) {
946 if (!isspace(sb
->buf
[i
++]))
953 static const char *find_author_by_nickname(const char *name
)
955 struct rev_info revs
;
956 struct commit
*commit
;
957 struct strbuf buf
= STRBUF_INIT
;
961 init_revisions(&revs
, NULL
);
962 strbuf_addf(&buf
, "--author=%s", name
);
967 setup_revisions(ac
, av
, &revs
, NULL
);
968 prepare_revision_walk(&revs
);
969 commit
= get_revision(&revs
);
971 struct pretty_print_context ctx
= {0};
972 ctx
.date_mode
= DATE_NORMAL
;
973 strbuf_release(&buf
);
974 format_commit_message(commit
, "%an <%ae>", &buf
, &ctx
);
975 return strbuf_detach(&buf
, NULL
);
977 die(_("No existing author found with '%s'"), name
);
981 static void handle_untracked_files_arg(struct wt_status
*s
)
983 if (!untracked_files_arg
)
984 ; /* default already initialized */
985 else if (!strcmp(untracked_files_arg
, "no"))
986 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
987 else if (!strcmp(untracked_files_arg
, "normal"))
988 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
989 else if (!strcmp(untracked_files_arg
, "all"))
990 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
992 die(_("Invalid untracked files mode '%s'"), untracked_files_arg
);
995 static const char *read_commit_message(const char *name
)
997 const char *out_enc
, *out
;
998 struct commit
*commit
;
1000 commit
= lookup_commit_reference_by_name(name
);
1002 die(_("could not lookup commit %s"), name
);
1003 out_enc
= get_commit_output_encoding();
1004 out
= logmsg_reencode(commit
, out_enc
);
1007 * If we failed to reencode the buffer, just copy it
1008 * byte for byte so the user can try to fix it up.
1009 * This also handles the case where input and output
1010 * encodings are identical.
1013 out
= xstrdup(commit
->buffer
);
1017 static int parse_and_validate_options(int argc
, const char *argv
[],
1018 const char * const usage
[],
1020 struct commit
*current_head
,
1021 struct wt_status
*s
)
1025 argc
= parse_options(argc
, argv
, prefix
, builtin_commit_options
, usage
,
1028 if (force_author
&& !strchr(force_author
, '>'))
1029 force_author
= find_author_by_nickname(force_author
);
1031 if (force_author
&& renew_authorship
)
1032 die(_("Using both --reset-author and --author does not make sense"));
1034 if (logfile
|| message
.len
|| use_message
|| fixup_message
)
1037 use_editor
= edit_flag
;
1039 setenv("GIT_EDITOR", ":", 1);
1041 /* Sanity check options */
1042 if (amend
&& !current_head
)
1043 die(_("You have nothing to amend."));
1044 if (amend
&& whence
!= FROM_COMMIT
)
1045 die(_("You are in the middle of a %s -- cannot amend."), whence_s());
1046 if (fixup_message
&& squash_message
)
1047 die(_("Options --squash and --fixup cannot be used together"));
1057 die(_("Only one of -c/-C/-F/--fixup can be used."));
1058 if (message
.len
&& f
> 0)
1059 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1061 use_message
= edit_message
;
1062 if (amend
&& !use_message
&& !fixup_message
)
1063 use_message
= "HEAD";
1064 if (!use_message
&& whence
!= FROM_CHERRY_PICK
&& renew_authorship
)
1065 die(_("--reset-author can be used only with -C, -c or --amend."));
1067 use_message_buffer
= read_commit_message(use_message
);
1068 if (!renew_authorship
) {
1069 author_message
= use_message
;
1070 author_message_buffer
= use_message_buffer
;
1073 if (whence
== FROM_CHERRY_PICK
&& !renew_authorship
) {
1074 author_message
= "CHERRY_PICK_HEAD";
1075 author_message_buffer
= read_commit_message(author_message
);
1078 if (patch_interactive
)
1081 if (!!also
+ !!only
+ !!all
+ !!interactive
> 1)
1082 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1083 if (argc
== 0 && (also
|| (only
&& !amend
)))
1084 die(_("No paths with --include/--only does not make sense."));
1085 if (argc
== 0 && only
&& amend
)
1086 only_include_assumed
= _("Clever... amending the last one with dirty index.");
1087 if (argc
> 0 && !also
&& !only
)
1088 only_include_assumed
= _("Explicit paths specified without -i nor -o; assuming --only paths...");
1089 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
1090 cleanup_mode
= use_editor
? CLEANUP_ALL
: CLEANUP_SPACE
;
1091 else if (!strcmp(cleanup_arg
, "verbatim"))
1092 cleanup_mode
= CLEANUP_NONE
;
1093 else if (!strcmp(cleanup_arg
, "whitespace"))
1094 cleanup_mode
= CLEANUP_SPACE
;
1095 else if (!strcmp(cleanup_arg
, "strip"))
1096 cleanup_mode
= CLEANUP_ALL
;
1098 die(_("Invalid cleanup mode %s"), cleanup_arg
);
1100 handle_untracked_files_arg(s
);
1102 if (all
&& argc
> 0)
1103 die(_("Paths with -a does not make sense."));
1105 if (null_termination
&& status_format
== STATUS_FORMAT_LONG
)
1106 status_format
= STATUS_FORMAT_PORCELAIN
;
1107 if (status_format
!= STATUS_FORMAT_LONG
)
1113 static int dry_run_commit(int argc
, const char **argv
, const char *prefix
,
1114 const struct commit
*current_head
, struct wt_status
*s
)
1117 const char *index_file
;
1119 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 1);
1120 commitable
= run_status(stdout
, index_file
, prefix
, 0, s
);
1121 rollback_index_files();
1123 return commitable
? 0 : 1;
1126 static int parse_status_slot(const char *var
, int offset
)
1128 if (!strcasecmp(var
+offset
, "header"))
1129 return WT_STATUS_HEADER
;
1130 if (!strcasecmp(var
+offset
, "branch"))
1131 return WT_STATUS_ONBRANCH
;
1132 if (!strcasecmp(var
+offset
, "updated")
1133 || !strcasecmp(var
+offset
, "added"))
1134 return WT_STATUS_UPDATED
;
1135 if (!strcasecmp(var
+offset
, "changed"))
1136 return WT_STATUS_CHANGED
;
1137 if (!strcasecmp(var
+offset
, "untracked"))
1138 return WT_STATUS_UNTRACKED
;
1139 if (!strcasecmp(var
+offset
, "nobranch"))
1140 return WT_STATUS_NOBRANCH
;
1141 if (!strcasecmp(var
+offset
, "unmerged"))
1142 return WT_STATUS_UNMERGED
;
1146 static int git_status_config(const char *k
, const char *v
, void *cb
)
1148 struct wt_status
*s
= cb
;
1150 if (!prefixcmp(k
, "column."))
1151 return git_column_config(k
, v
, "status", &colopts
);
1152 if (!strcmp(k
, "status.submodulesummary")) {
1154 s
->submodule_summary
= git_config_bool_or_int(k
, v
, &is_bool
);
1155 if (is_bool
&& s
->submodule_summary
)
1156 s
->submodule_summary
= -1;
1159 if (!strcmp(k
, "status.color") || !strcmp(k
, "color.status")) {
1160 s
->use_color
= git_config_colorbool(k
, v
);
1163 if (!prefixcmp(k
, "status.color.") || !prefixcmp(k
, "color.status.")) {
1164 int slot
= parse_status_slot(k
, 13);
1168 return config_error_nonbool(k
);
1169 color_parse(v
, k
, s
->color_palette
[slot
]);
1172 if (!strcmp(k
, "status.relativepaths")) {
1173 s
->relative_paths
= git_config_bool(k
, v
);
1176 if (!strcmp(k
, "status.showuntrackedfiles")) {
1178 return config_error_nonbool(k
);
1179 else if (!strcmp(v
, "no"))
1180 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1181 else if (!strcmp(v
, "normal"))
1182 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1183 else if (!strcmp(v
, "all"))
1184 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1186 return error(_("Invalid untracked files mode '%s'"), v
);
1189 return git_diff_ui_config(k
, v
, NULL
);
1192 int cmd_status(int argc
, const char **argv
, const char *prefix
)
1196 unsigned char sha1
[20];
1197 static struct option builtin_status_options
[] = {
1198 OPT__VERBOSE(&verbose
, "be verbose"),
1199 OPT_SET_INT('s', "short", &status_format
,
1200 "show status concisely", STATUS_FORMAT_SHORT
),
1201 OPT_BOOLEAN('b', "branch", &status_show_branch
,
1202 "show branch information"),
1203 OPT_SET_INT(0, "porcelain", &status_format
,
1204 "machine-readable output",
1205 STATUS_FORMAT_PORCELAIN
),
1206 OPT_BOOLEAN('z', "null", &null_termination
,
1207 "terminate entries with NUL"),
1208 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
,
1210 "show untracked files, optional modes: all, normal, no. (Default: all)",
1211 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1212 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status
,
1213 "show ignored files"),
1214 { OPTION_STRING
, 0, "ignore-submodules", &ignore_submodule_arg
, "when",
1215 "ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)",
1216 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1217 OPT_COLUMN(0, "column", &colopts
, "list untracked files in columns"),
1221 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1222 usage_with_options(builtin_status_usage
, builtin_status_options
);
1224 wt_status_prepare(&s
);
1225 gitmodules_config();
1226 git_config(git_status_config
, &s
);
1227 determine_whence(&s
);
1228 argc
= parse_options(argc
, argv
, prefix
,
1229 builtin_status_options
,
1230 builtin_status_usage
, 0);
1231 finalize_colopts(&colopts
, -1);
1232 s
.colopts
= colopts
;
1234 if (null_termination
&& status_format
== STATUS_FORMAT_LONG
)
1235 status_format
= STATUS_FORMAT_PORCELAIN
;
1237 handle_untracked_files_arg(&s
);
1238 if (show_ignored_in_status
)
1239 s
.show_ignored_files
= 1;
1241 s
.pathspec
= get_pathspec(prefix
, argv
);
1243 read_cache_preload(s
.pathspec
);
1244 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, s
.pathspec
, NULL
, NULL
);
1246 fd
= hold_locked_index(&index_lock
, 0);
1248 update_index_if_able(&the_index
, &index_lock
);
1250 s
.is_initial
= get_sha1(s
.reference
, sha1
) ? 1 : 0;
1251 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1252 wt_status_collect(&s
);
1254 if (s
.relative_paths
)
1257 switch (status_format
) {
1258 case STATUS_FORMAT_SHORT
:
1259 wt_shortstatus_print(&s
, null_termination
, status_show_branch
);
1261 case STATUS_FORMAT_PORCELAIN
:
1262 wt_porcelain_print(&s
, null_termination
);
1264 case STATUS_FORMAT_LONG
:
1265 s
.verbose
= verbose
;
1266 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1267 wt_status_print(&s
);
1273 static void print_summary(const char *prefix
, const unsigned char *sha1
,
1276 struct rev_info rev
;
1277 struct commit
*commit
;
1278 struct strbuf format
= STRBUF_INIT
;
1279 unsigned char junk_sha1
[20];
1281 struct pretty_print_context pctx
= {0};
1282 struct strbuf author_ident
= STRBUF_INIT
;
1283 struct strbuf committer_ident
= STRBUF_INIT
;
1285 commit
= lookup_commit(sha1
);
1287 die(_("couldn't look up newly created commit"));
1288 if (!commit
|| parse_commit(commit
))
1289 die(_("could not parse newly created commit"));
1291 strbuf_addstr(&format
, "format:%h] %s");
1293 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1294 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1295 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1296 strbuf_addstr(&format
, "\n Author: ");
1297 strbuf_addbuf_percentquote(&format
, &author_ident
);
1299 if (!user_ident_sufficiently_given()) {
1300 strbuf_addstr(&format
, "\n Committer: ");
1301 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1302 if (advice_implicit_identity
) {
1303 strbuf_addch(&format
, '\n');
1304 strbuf_addstr(&format
, _(implicit_ident_advice
));
1307 strbuf_release(&author_ident
);
1308 strbuf_release(&committer_ident
);
1310 init_revisions(&rev
, prefix
);
1311 setup_revisions(0, NULL
, &rev
, NULL
);
1314 rev
.diffopt
.output_format
=
1315 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1317 rev
.verbose_header
= 1;
1318 rev
.show_root_diff
= 1;
1319 get_commit_format(format
.buf
, &rev
);
1320 rev
.always_show_header
= 0;
1321 rev
.diffopt
.detect_rename
= 1;
1322 rev
.diffopt
.break_opt
= 0;
1323 diff_setup_done(&rev
.diffopt
);
1325 head
= resolve_ref_unsafe("HEAD", junk_sha1
, 0, NULL
);
1327 !prefixcmp(head
, "refs/heads/") ?
1329 !strcmp(head
, "HEAD") ?
1330 _("detached HEAD") :
1332 initial_commit
? _(" (root-commit)") : "");
1334 if (!log_tree_commit(&rev
, commit
)) {
1335 rev
.always_show_header
= 1;
1336 rev
.use_terminator
= 1;
1337 log_tree_commit(&rev
, commit
);
1340 strbuf_release(&format
);
1343 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1345 struct wt_status
*s
= cb
;
1348 if (!strcmp(k
, "commit.template"))
1349 return git_config_pathname(&template_file
, k
, v
);
1350 if (!strcmp(k
, "commit.status")) {
1351 include_status
= git_config_bool(k
, v
);
1355 status
= git_gpg_config(k
, v
, NULL
);
1358 return git_status_config(k
, v
, s
);
1361 static const char post_rewrite_hook
[] = "hooks/post-rewrite";
1363 static int run_rewrite_hook(const unsigned char *oldsha1
,
1364 const unsigned char *newsha1
)
1366 /* oldsha1 SP newsha1 LF NUL */
1367 static char buf
[2*40 + 3];
1368 struct child_process proc
;
1369 const char *argv
[3];
1373 if (access(git_path(post_rewrite_hook
), X_OK
) < 0)
1376 argv
[0] = git_path(post_rewrite_hook
);
1380 memset(&proc
, 0, sizeof(proc
));
1383 proc
.stdout_to_stderr
= 1;
1385 code
= start_command(&proc
);
1388 n
= snprintf(buf
, sizeof(buf
), "%s %s\n",
1389 sha1_to_hex(oldsha1
), sha1_to_hex(newsha1
));
1390 write_in_full(proc
.in
, buf
, n
);
1392 return finish_command(&proc
);
1395 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1397 struct strbuf sb
= STRBUF_INIT
;
1398 struct strbuf author_ident
= STRBUF_INIT
;
1399 const char *index_file
, *reflog_msg
;
1401 unsigned char sha1
[20];
1402 struct ref_lock
*ref_lock
;
1403 struct commit_list
*parents
= NULL
, **pptr
= &parents
;
1404 struct stat statbuf
;
1405 int allow_fast_forward
= 1;
1407 struct commit
*current_head
= NULL
;
1408 struct commit_extra_header
*extra
= NULL
;
1410 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1411 usage_with_options(builtin_commit_usage
, builtin_commit_options
);
1413 wt_status_prepare(&s
);
1414 git_config(git_commit_config
, &s
);
1415 determine_whence(&s
);
1417 if (get_sha1("HEAD", sha1
))
1418 current_head
= NULL
;
1420 current_head
= lookup_commit_or_die(sha1
, "HEAD");
1421 if (!current_head
|| parse_commit(current_head
))
1422 die(_("could not parse HEAD commit"));
1424 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_usage
,
1425 prefix
, current_head
, &s
);
1427 return dry_run_commit(argc
, argv
, prefix
, current_head
, &s
);
1428 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 0);
1430 /* Set up everything for writing the commit object. This includes
1431 running hooks, writing the trees, and interacting with the user. */
1432 if (!prepare_to_commit(index_file
, prefix
,
1433 current_head
, &s
, &author_ident
)) {
1434 rollback_index_files();
1438 /* Determine parents */
1439 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1440 if (!current_head
) {
1442 reflog_msg
= "commit (initial)";
1444 struct commit_list
*c
;
1447 reflog_msg
= "commit (amend)";
1448 for (c
= current_head
->parents
; c
; c
= c
->next
)
1449 pptr
= &commit_list_insert(c
->item
, pptr
)->next
;
1450 } else if (whence
== FROM_MERGE
) {
1451 struct strbuf m
= STRBUF_INIT
;
1455 reflog_msg
= "commit (merge)";
1456 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1457 fp
= fopen(git_path("MERGE_HEAD"), "r");
1459 die_errno(_("could not open '%s' for reading"),
1460 git_path("MERGE_HEAD"));
1461 while (strbuf_getline(&m
, fp
, '\n') != EOF
) {
1462 struct commit
*parent
;
1464 parent
= get_merge_parent(m
.buf
);
1466 die(_("Corrupt MERGE_HEAD file (%s)"), m
.buf
);
1467 pptr
= &commit_list_insert(parent
, pptr
)->next
;
1471 if (!stat(git_path("MERGE_MODE"), &statbuf
)) {
1472 if (strbuf_read_file(&sb
, git_path("MERGE_MODE"), 0) < 0)
1473 die_errno(_("could not read MERGE_MODE"));
1474 if (!strcmp(sb
.buf
, "no-ff"))
1475 allow_fast_forward
= 0;
1477 if (allow_fast_forward
)
1478 parents
= reduce_heads(parents
);
1481 reflog_msg
= (whence
== FROM_CHERRY_PICK
)
1482 ? "commit (cherry-pick)"
1484 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1487 /* Finally, get the commit message */
1489 if (strbuf_read_file(&sb
, git_path(commit_editmsg
), 0) < 0) {
1490 int saved_errno
= errno
;
1491 rollback_index_files();
1492 die(_("could not read commit message: %s"), strerror(saved_errno
));
1495 /* Truncate the message just before the diff, if any. */
1497 p
= strstr(sb
.buf
, "\ndiff --git ");
1499 strbuf_setlen(&sb
, p
- sb
.buf
+ 1);
1502 if (cleanup_mode
!= CLEANUP_NONE
)
1503 stripspace(&sb
, cleanup_mode
== CLEANUP_ALL
);
1504 if (message_is_empty(&sb
) && !allow_empty_message
) {
1505 rollback_index_files();
1506 fprintf(stderr
, _("Aborting commit due to empty commit message.\n"));
1511 const char *exclude_gpgsig
[2] = { "gpgsig", NULL
};
1512 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1514 struct commit_extra_header
**tail
= &extra
;
1515 append_merge_tag_headers(parents
, &tail
);
1518 if (commit_tree_extended(&sb
, active_cache_tree
->sha1
, parents
, sha1
,
1519 author_ident
.buf
, sign_commit
, extra
)) {
1520 rollback_index_files();
1521 die(_("failed to write commit object"));
1523 strbuf_release(&author_ident
);
1524 free_commit_extra_headers(extra
);
1526 ref_lock
= lock_any_ref_for_update("HEAD",
1529 : current_head
->object
.sha1
,
1532 nl
= strchr(sb
.buf
, '\n');
1534 strbuf_setlen(&sb
, nl
+ 1 - sb
.buf
);
1536 strbuf_addch(&sb
, '\n');
1537 strbuf_insert(&sb
, 0, reflog_msg
, strlen(reflog_msg
));
1538 strbuf_insert(&sb
, strlen(reflog_msg
), ": ", 2);
1541 rollback_index_files();
1542 die(_("cannot lock HEAD ref"));
1544 if (write_ref_sha1(ref_lock
, sha1
, sb
.buf
) < 0) {
1545 rollback_index_files();
1546 die(_("cannot update HEAD ref"));
1549 unlink(git_path("CHERRY_PICK_HEAD"));
1550 unlink(git_path("REVERT_HEAD"));
1551 unlink(git_path("MERGE_HEAD"));
1552 unlink(git_path("MERGE_MSG"));
1553 unlink(git_path("MERGE_MODE"));
1554 unlink(git_path("SQUASH_MSG"));
1556 if (commit_index_files())
1557 die (_("Repository has been updated, but unable to write\n"
1558 "new_index file. Check that disk is not full or quota is\n"
1559 "not exceeded, and then \"git reset HEAD\" to recover."));
1562 run_hook(get_index_file(), "post-commit", NULL
);
1563 if (amend
&& !no_post_rewrite
) {
1564 struct notes_rewrite_cfg
*cfg
;
1565 cfg
= init_copy_notes_for_rewrite("amend");
1567 /* we are amending, so current_head is not NULL */
1568 copy_note_for_rewrite(cfg
, current_head
->object
.sha1
, sha1
);
1569 finish_copy_notes_for_rewrite(cfg
);
1571 run_rewrite_hook(current_head
->object
.sha1
, sha1
);
1574 print_summary(prefix
, sha1
, !current_head
);