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
:
208 s
= _("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
;
548 a
= strstr(author_message_buffer
, "\nauthor ");
550 die(_("invalid commit: %s"), author_message
);
552 lb
= strchrnul(a
+ strlen("\nauthor "), '<');
553 rb
= strchrnul(lb
, '>');
554 eol
= strchrnul(rb
, '\n');
555 if (!*lb
|| !*rb
|| !*eol
)
556 die(_("invalid commit: %s"), author_message
);
558 if (lb
== a
+ strlen("\nauthor "))
559 /* \nauthor <foo@example.com> */
560 name
= xcalloc(1, 1);
562 name
= xmemdupz(a
+ strlen("\nauthor "),
564 (a
+ strlen("\nauthor "))));
565 email
= xmemdupz(lb
+ strlen("<"), rb
- (lb
+ strlen("<")));
566 date
= xmemdupz(rb
+ strlen("> "), eol
- (rb
+ strlen("> ")));
567 len
= eol
- (rb
+ strlen("> "));
568 date
= xmalloc(len
+ 2);
570 memcpy(date
+ 1, rb
+ strlen("> "), len
);
571 date
[len
+ 1] = '\0';
575 const char *lb
= strstr(force_author
, " <");
576 const char *rb
= strchr(force_author
, '>');
579 die(_("malformed --author parameter"));
580 name
= xstrndup(force_author
, lb
- force_author
);
581 email
= xstrndup(lb
+ 2, rb
- (lb
+ 2));
586 strbuf_addstr(author_ident
, fmt_ident(name
, email
, date
,
587 IDENT_ERROR_ON_NO_NAME
));
590 static int ends_rfc2822_footer(struct strbuf
*sb
)
597 const char *buf
= sb
->buf
;
599 for (i
= len
- 1; i
> 0; i
--) {
600 if (hit
&& buf
[i
] == '\n')
602 hit
= (buf
[i
] == '\n');
605 while (i
< len
- 1 && buf
[i
] == '\n')
608 for (; i
< len
; i
= k
) {
609 for (k
= i
; k
< len
&& buf
[k
] != '\n'; k
++)
613 if ((buf
[k
] == ' ' || buf
[k
] == '\t') && !first
)
618 for (j
= 0; i
+ j
< len
; j
++) {
631 static char *cut_ident_timestamp_part(char *string
)
633 char *ket
= strrchr(string
, '>');
634 if (!ket
|| ket
[1] != ' ')
635 die(_("Malformed ident string: '%s'"), string
);
640 static int prepare_to_commit(const char *index_file
, const char *prefix
,
641 struct commit
*current_head
,
643 struct strbuf
*author_ident
)
646 struct strbuf committer_ident
= STRBUF_INIT
;
647 int commitable
, saved_color_setting
;
648 struct strbuf sb
= STRBUF_INIT
;
650 const char *hook_arg1
= NULL
;
651 const char *hook_arg2
= NULL
;
653 int clean_message_contents
= (cleanup_mode
!= CLEANUP_NONE
);
655 if (!no_verify
&& run_hook(index_file
, "pre-commit", NULL
))
658 if (squash_message
) {
660 * Insert the proper subject line before other commit
661 * message options add their content.
663 if (use_message
&& !strcmp(use_message
, squash_message
))
664 strbuf_addstr(&sb
, "squash! ");
666 struct pretty_print_context ctx
= {0};
668 c
= lookup_commit_reference_by_name(squash_message
);
670 die(_("could not lookup commit %s"), squash_message
);
671 ctx
.output_encoding
= get_commit_output_encoding();
672 format_commit_message(c
, "squash! %s\n\n", &sb
,
678 strbuf_addbuf(&sb
, &message
);
679 hook_arg1
= "message";
680 } else if (logfile
&& !strcmp(logfile
, "-")) {
682 fprintf(stderr
, _("(reading log message from standard input)\n"));
683 if (strbuf_read(&sb
, 0, 0) < 0)
684 die_errno(_("could not read log from standard input"));
685 hook_arg1
= "message";
686 } else if (logfile
) {
687 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
688 die_errno(_("could not read log file '%s'"),
690 hook_arg1
= "message";
691 } else if (use_message
) {
692 buffer
= strstr(use_message_buffer
, "\n\n");
693 if (!buffer
|| buffer
[2] == '\0')
694 die(_("commit has empty message"));
695 strbuf_add(&sb
, buffer
+ 2, strlen(buffer
+ 2));
696 hook_arg1
= "commit";
697 hook_arg2
= use_message
;
698 } else if (fixup_message
) {
699 struct pretty_print_context ctx
= {0};
700 struct commit
*commit
;
701 commit
= lookup_commit_reference_by_name(fixup_message
);
703 die(_("could not lookup commit %s"), fixup_message
);
704 ctx
.output_encoding
= get_commit_output_encoding();
705 format_commit_message(commit
, "fixup! %s\n\n",
707 hook_arg1
= "message";
708 } else if (!stat(git_path("MERGE_MSG"), &statbuf
)) {
709 if (strbuf_read_file(&sb
, git_path("MERGE_MSG"), 0) < 0)
710 die_errno(_("could not read MERGE_MSG"));
712 } else if (!stat(git_path("SQUASH_MSG"), &statbuf
)) {
713 if (strbuf_read_file(&sb
, git_path("SQUASH_MSG"), 0) < 0)
714 die_errno(_("could not read SQUASH_MSG"));
715 hook_arg1
= "squash";
716 } else if (template_file
) {
717 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
718 die_errno(_("could not read '%s'"), template_file
);
719 hook_arg1
= "template";
720 clean_message_contents
= 0;
724 * The remaining cases don't modify the template message, but
725 * just set the argument(s) to the prepare-commit-msg hook.
727 else if (whence
== FROM_MERGE
)
729 else if (whence
== FROM_CHERRY_PICK
) {
730 hook_arg1
= "commit";
731 hook_arg2
= "CHERRY_PICK_HEAD";
734 if (squash_message
) {
736 * If squash_commit was used for the commit subject,
737 * then we're possibly hijacking other commit log options.
738 * Reset the hook args to tell the real story.
740 hook_arg1
= "message";
744 s
->fp
= fopen(git_path(commit_editmsg
), "w");
746 die_errno(_("could not open '%s'"), git_path(commit_editmsg
));
748 if (clean_message_contents
)
752 struct strbuf sob
= STRBUF_INIT
;
755 strbuf_addstr(&sob
, sign_off_header
);
756 strbuf_addstr(&sob
, fmt_name(getenv("GIT_COMMITTER_NAME"),
757 getenv("GIT_COMMITTER_EMAIL")));
758 strbuf_addch(&sob
, '\n');
759 for (i
= sb
.len
- 1; i
> 0 && sb
.buf
[i
- 1] != '\n'; i
--)
761 if (prefixcmp(sb
.buf
+ i
, sob
.buf
)) {
762 if (!i
|| !ends_rfc2822_footer(&sb
))
763 strbuf_addch(&sb
, '\n');
764 strbuf_addbuf(&sb
, &sob
);
766 strbuf_release(&sob
);
769 if (fwrite(sb
.buf
, 1, sb
.len
, s
->fp
) < sb
.len
)
770 die_errno(_("could not write commit template"));
774 /* This checks and barfs if author is badly specified */
775 determine_author_info(author_ident
);
777 /* This checks if committer ident is explicitly given */
778 strbuf_addstr(&committer_ident
, git_committer_info(0));
779 if (use_editor
&& include_status
) {
780 char *ai_tmp
, *ci_tmp
;
781 if (whence
!= FROM_COMMIT
)
782 status_printf_ln(s
, GIT_COLOR_NORMAL
,
784 "It looks like you may be committing a %s.\n"
785 "If this is not correct, please remove the file\n"
790 git_path(whence
== FROM_MERGE
792 : "CHERRY_PICK_HEAD"));
794 fprintf(s
->fp
, "\n");
795 status_printf(s
, GIT_COLOR_NORMAL
,
796 _("Please enter the commit message for your changes."));
797 if (cleanup_mode
== CLEANUP_ALL
)
798 status_printf_more(s
, GIT_COLOR_NORMAL
,
799 _(" Lines starting\n"
800 "with '#' will be ignored, and an empty"
801 " message aborts the commit.\n"));
802 else /* CLEANUP_SPACE, that is. */
803 status_printf_more(s
, GIT_COLOR_NORMAL
,
804 _(" Lines starting\n"
805 "with '#' will be kept; you may remove them"
806 " yourself if you want to.\n"
807 "An empty message aborts the commit.\n"));
808 if (only_include_assumed
)
809 status_printf_ln(s
, GIT_COLOR_NORMAL
,
810 "%s", only_include_assumed
);
812 ai_tmp
= cut_ident_timestamp_part(author_ident
->buf
);
813 ci_tmp
= cut_ident_timestamp_part(committer_ident
.buf
);
814 if (strcmp(author_ident
->buf
, committer_ident
.buf
))
815 status_printf_ln(s
, GIT_COLOR_NORMAL
,
818 ident_shown
++ ? "" : "\n",
821 if (!user_ident_sufficiently_given())
822 status_printf_ln(s
, GIT_COLOR_NORMAL
,
825 ident_shown
++ ? "" : "\n",
826 committer_ident
.buf
);
829 status_printf_ln(s
, GIT_COLOR_NORMAL
, "");
831 saved_color_setting
= s
->use_color
;
833 commitable
= run_status(s
->fp
, index_file
, prefix
, 1, s
);
834 s
->use_color
= saved_color_setting
;
839 unsigned char sha1
[20];
840 const char *parent
= "HEAD";
842 if (!active_nr
&& read_cache() < 0)
843 die(_("Cannot read index"));
848 if (get_sha1(parent
, sha1
))
849 commitable
= !!active_nr
;
851 commitable
= index_differs_from(parent
, 0);
853 strbuf_release(&committer_ident
);
858 * Reject an attempt to record a non-merge empty commit without
859 * explicit --allow-empty. In the cherry-pick case, it may be
860 * empty due to conflict resolution, which the user should okay.
862 if (!commitable
&& whence
!= FROM_MERGE
&& !allow_empty
&&
863 !(amend
&& is_a_merge(current_head
))) {
864 run_status(stdout
, index_file
, prefix
, 0, s
);
866 fputs(_(empty_amend_advice
), stderr
);
867 else if (whence
== FROM_CHERRY_PICK
)
868 fputs(_(empty_cherry_pick_advice
), stderr
);
873 * Re-read the index as pre-commit hook could have updated it,
874 * and write it out as a tree. We must do this before we invoke
875 * the editor and after we invoke run_status above.
878 read_cache_from(index_file
);
879 if (update_main_cache_tree(0)) {
880 error(_("Error building trees"));
884 if (run_hook(index_file
, "prepare-commit-msg",
885 git_path(commit_editmsg
), hook_arg1
, hook_arg2
, NULL
))
889 char index
[PATH_MAX
];
890 const char *env
[2] = { NULL
};
892 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
893 if (launch_editor(git_path(commit_editmsg
), NULL
, env
)) {
895 _("Please supply the message using either -m or -F option.\n"));
901 run_hook(index_file
, "commit-msg", git_path(commit_editmsg
), NULL
)) {
909 * Find out if the message in the strbuf contains only whitespace and
910 * Signed-off-by lines.
912 static int message_is_empty(struct strbuf
*sb
)
914 struct strbuf tmpl
= STRBUF_INIT
;
916 int eol
, i
, start
= 0;
918 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
921 /* See if the template is just a prefix of the message. */
922 if (template_file
&& strbuf_read_file(&tmpl
, template_file
, 0) > 0) {
923 stripspace(&tmpl
, cleanup_mode
== CLEANUP_ALL
);
924 if (start
+ tmpl
.len
<= sb
->len
&&
925 memcmp(tmpl
.buf
, sb
->buf
+ start
, tmpl
.len
) == 0)
928 strbuf_release(&tmpl
);
930 /* Check if the rest is just whitespace and Signed-of-by's. */
931 for (i
= start
; i
< sb
->len
; i
++) {
932 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
938 if (strlen(sign_off_header
) <= eol
- i
&&
939 !prefixcmp(sb
->buf
+ i
, sign_off_header
)) {
944 if (!isspace(sb
->buf
[i
++]))
951 static const char *find_author_by_nickname(const char *name
)
953 struct rev_info revs
;
954 struct commit
*commit
;
955 struct strbuf buf
= STRBUF_INIT
;
959 init_revisions(&revs
, NULL
);
960 strbuf_addf(&buf
, "--author=%s", name
);
965 setup_revisions(ac
, av
, &revs
, NULL
);
966 prepare_revision_walk(&revs
);
967 commit
= get_revision(&revs
);
969 struct pretty_print_context ctx
= {0};
970 ctx
.date_mode
= DATE_NORMAL
;
971 strbuf_release(&buf
);
972 format_commit_message(commit
, "%an <%ae>", &buf
, &ctx
);
973 return strbuf_detach(&buf
, NULL
);
975 die(_("No existing author found with '%s'"), name
);
979 static void handle_untracked_files_arg(struct wt_status
*s
)
981 if (!untracked_files_arg
)
982 ; /* default already initialized */
983 else if (!strcmp(untracked_files_arg
, "no"))
984 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
985 else if (!strcmp(untracked_files_arg
, "normal"))
986 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
987 else if (!strcmp(untracked_files_arg
, "all"))
988 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
990 die(_("Invalid untracked files mode '%s'"), untracked_files_arg
);
993 static const char *read_commit_message(const char *name
)
995 const char *out_enc
, *out
;
996 struct commit
*commit
;
998 commit
= lookup_commit_reference_by_name(name
);
1000 die(_("could not lookup commit %s"), name
);
1001 out_enc
= get_commit_output_encoding();
1002 out
= logmsg_reencode(commit
, out_enc
);
1005 * If we failed to reencode the buffer, just copy it
1006 * byte for byte so the user can try to fix it up.
1007 * This also handles the case where input and output
1008 * encodings are identical.
1011 out
= xstrdup(commit
->buffer
);
1015 static int parse_and_validate_options(int argc
, const char *argv
[],
1016 const char * const usage
[],
1018 struct commit
*current_head
,
1019 struct wt_status
*s
)
1023 argc
= parse_options(argc
, argv
, prefix
, builtin_commit_options
, usage
,
1026 if (force_author
&& !strchr(force_author
, '>'))
1027 force_author
= find_author_by_nickname(force_author
);
1029 if (force_author
&& renew_authorship
)
1030 die(_("Using both --reset-author and --author does not make sense"));
1032 if (logfile
|| message
.len
|| use_message
|| fixup_message
)
1035 use_editor
= edit_flag
;
1037 setenv("GIT_EDITOR", ":", 1);
1039 /* Sanity check options */
1040 if (amend
&& !current_head
)
1041 die(_("You have nothing to amend."));
1042 if (amend
&& whence
!= FROM_COMMIT
)
1043 die(_("You are in the middle of a %s -- cannot amend."), whence_s());
1044 if (fixup_message
&& squash_message
)
1045 die(_("Options --squash and --fixup cannot be used together"));
1055 die(_("Only one of -c/-C/-F/--fixup can be used."));
1056 if (message
.len
&& f
> 0)
1057 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1059 use_message
= edit_message
;
1060 if (amend
&& !use_message
&& !fixup_message
)
1061 use_message
= "HEAD";
1062 if (!use_message
&& whence
!= FROM_CHERRY_PICK
&& renew_authorship
)
1063 die(_("--reset-author can be used only with -C, -c or --amend."));
1065 use_message_buffer
= read_commit_message(use_message
);
1066 if (!renew_authorship
) {
1067 author_message
= use_message
;
1068 author_message_buffer
= use_message_buffer
;
1071 if (whence
== FROM_CHERRY_PICK
&& !renew_authorship
) {
1072 author_message
= "CHERRY_PICK_HEAD";
1073 author_message_buffer
= read_commit_message(author_message
);
1076 if (patch_interactive
)
1079 if (!!also
+ !!only
+ !!all
+ !!interactive
> 1)
1080 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1081 if (argc
== 0 && (also
|| (only
&& !amend
)))
1082 die(_("No paths with --include/--only does not make sense."));
1083 if (argc
== 0 && only
&& amend
)
1084 only_include_assumed
= _("Clever... amending the last one with dirty index.");
1085 if (argc
> 0 && !also
&& !only
)
1086 only_include_assumed
= _("Explicit paths specified without -i nor -o; assuming --only paths...");
1087 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
1088 cleanup_mode
= use_editor
? CLEANUP_ALL
: CLEANUP_SPACE
;
1089 else if (!strcmp(cleanup_arg
, "verbatim"))
1090 cleanup_mode
= CLEANUP_NONE
;
1091 else if (!strcmp(cleanup_arg
, "whitespace"))
1092 cleanup_mode
= CLEANUP_SPACE
;
1093 else if (!strcmp(cleanup_arg
, "strip"))
1094 cleanup_mode
= CLEANUP_ALL
;
1096 die(_("Invalid cleanup mode %s"), cleanup_arg
);
1098 handle_untracked_files_arg(s
);
1100 if (all
&& argc
> 0)
1101 die(_("Paths with -a does not make sense."));
1103 if (null_termination
&& status_format
== STATUS_FORMAT_LONG
)
1104 status_format
= STATUS_FORMAT_PORCELAIN
;
1105 if (status_format
!= STATUS_FORMAT_LONG
)
1111 static int dry_run_commit(int argc
, const char **argv
, const char *prefix
,
1112 const struct commit
*current_head
, struct wt_status
*s
)
1115 const char *index_file
;
1117 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 1);
1118 commitable
= run_status(stdout
, index_file
, prefix
, 0, s
);
1119 rollback_index_files();
1121 return commitable
? 0 : 1;
1124 static int parse_status_slot(const char *var
, int offset
)
1126 if (!strcasecmp(var
+offset
, "header"))
1127 return WT_STATUS_HEADER
;
1128 if (!strcasecmp(var
+offset
, "branch"))
1129 return WT_STATUS_ONBRANCH
;
1130 if (!strcasecmp(var
+offset
, "updated")
1131 || !strcasecmp(var
+offset
, "added"))
1132 return WT_STATUS_UPDATED
;
1133 if (!strcasecmp(var
+offset
, "changed"))
1134 return WT_STATUS_CHANGED
;
1135 if (!strcasecmp(var
+offset
, "untracked"))
1136 return WT_STATUS_UNTRACKED
;
1137 if (!strcasecmp(var
+offset
, "nobranch"))
1138 return WT_STATUS_NOBRANCH
;
1139 if (!strcasecmp(var
+offset
, "unmerged"))
1140 return WT_STATUS_UNMERGED
;
1144 static int git_status_config(const char *k
, const char *v
, void *cb
)
1146 struct wt_status
*s
= cb
;
1148 if (!strcmp(k
, "status.submodulesummary")) {
1150 s
->submodule_summary
= git_config_bool_or_int(k
, v
, &is_bool
);
1151 if (is_bool
&& s
->submodule_summary
)
1152 s
->submodule_summary
= -1;
1155 if (!strcmp(k
, "status.color") || !strcmp(k
, "color.status")) {
1156 s
->use_color
= git_config_colorbool(k
, v
);
1159 if (!prefixcmp(k
, "status.color.") || !prefixcmp(k
, "color.status.")) {
1160 int slot
= parse_status_slot(k
, 13);
1164 return config_error_nonbool(k
);
1165 color_parse(v
, k
, s
->color_palette
[slot
]);
1168 if (!strcmp(k
, "status.relativepaths")) {
1169 s
->relative_paths
= git_config_bool(k
, v
);
1172 if (!strcmp(k
, "status.showuntrackedfiles")) {
1174 return config_error_nonbool(k
);
1175 else if (!strcmp(v
, "no"))
1176 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1177 else if (!strcmp(v
, "normal"))
1178 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1179 else if (!strcmp(v
, "all"))
1180 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1182 return error(_("Invalid untracked files mode '%s'"), v
);
1185 return git_diff_ui_config(k
, v
, NULL
);
1188 int cmd_status(int argc
, const char **argv
, const char *prefix
)
1192 unsigned char sha1
[20];
1193 static struct option builtin_status_options
[] = {
1194 OPT__VERBOSE(&verbose
, "be verbose"),
1195 OPT_SET_INT('s', "short", &status_format
,
1196 "show status concisely", STATUS_FORMAT_SHORT
),
1197 OPT_BOOLEAN('b', "branch", &status_show_branch
,
1198 "show branch information"),
1199 OPT_SET_INT(0, "porcelain", &status_format
,
1200 "machine-readable output",
1201 STATUS_FORMAT_PORCELAIN
),
1202 OPT_BOOLEAN('z', "null", &null_termination
,
1203 "terminate entries with NUL"),
1204 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
,
1206 "show untracked files, optional modes: all, normal, no. (Default: all)",
1207 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1208 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status
,
1209 "show ignored files"),
1210 { OPTION_STRING
, 0, "ignore-submodules", &ignore_submodule_arg
, "when",
1211 "ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)",
1212 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1216 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1217 usage_with_options(builtin_status_usage
, builtin_status_options
);
1219 wt_status_prepare(&s
);
1220 gitmodules_config();
1221 git_config(git_status_config
, &s
);
1222 determine_whence(&s
);
1223 argc
= parse_options(argc
, argv
, prefix
,
1224 builtin_status_options
,
1225 builtin_status_usage
, 0);
1227 if (null_termination
&& status_format
== STATUS_FORMAT_LONG
)
1228 status_format
= STATUS_FORMAT_PORCELAIN
;
1230 handle_untracked_files_arg(&s
);
1231 if (show_ignored_in_status
)
1232 s
.show_ignored_files
= 1;
1234 s
.pathspec
= get_pathspec(prefix
, argv
);
1236 read_cache_preload(s
.pathspec
);
1237 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, s
.pathspec
, NULL
, NULL
);
1239 fd
= hold_locked_index(&index_lock
, 0);
1241 update_index_if_able(&the_index
, &index_lock
);
1243 s
.is_initial
= get_sha1(s
.reference
, sha1
) ? 1 : 0;
1244 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1245 wt_status_collect(&s
);
1247 if (s
.relative_paths
)
1250 switch (status_format
) {
1251 case STATUS_FORMAT_SHORT
:
1252 wt_shortstatus_print(&s
, null_termination
, status_show_branch
);
1254 case STATUS_FORMAT_PORCELAIN
:
1255 wt_porcelain_print(&s
, null_termination
);
1257 case STATUS_FORMAT_LONG
:
1258 s
.verbose
= verbose
;
1259 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1260 wt_status_print(&s
);
1266 static void print_summary(const char *prefix
, const unsigned char *sha1
,
1269 struct rev_info rev
;
1270 struct commit
*commit
;
1271 struct strbuf format
= STRBUF_INIT
;
1272 unsigned char junk_sha1
[20];
1274 struct pretty_print_context pctx
= {0};
1275 struct strbuf author_ident
= STRBUF_INIT
;
1276 struct strbuf committer_ident
= STRBUF_INIT
;
1278 commit
= lookup_commit(sha1
);
1280 die(_("couldn't look up newly created commit"));
1281 if (!commit
|| parse_commit(commit
))
1282 die(_("could not parse newly created commit"));
1284 strbuf_addstr(&format
, "format:%h] %s");
1286 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1287 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1288 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1289 strbuf_addstr(&format
, "\n Author: ");
1290 strbuf_addbuf_percentquote(&format
, &author_ident
);
1292 if (!user_ident_sufficiently_given()) {
1293 strbuf_addstr(&format
, "\n Committer: ");
1294 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1295 if (advice_implicit_identity
) {
1296 strbuf_addch(&format
, '\n');
1297 strbuf_addstr(&format
, _(implicit_ident_advice
));
1300 strbuf_release(&author_ident
);
1301 strbuf_release(&committer_ident
);
1303 init_revisions(&rev
, prefix
);
1304 setup_revisions(0, NULL
, &rev
, NULL
);
1307 rev
.diffopt
.output_format
=
1308 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1310 rev
.verbose_header
= 1;
1311 rev
.show_root_diff
= 1;
1312 get_commit_format(format
.buf
, &rev
);
1313 rev
.always_show_header
= 0;
1314 rev
.diffopt
.detect_rename
= 1;
1315 rev
.diffopt
.break_opt
= 0;
1316 diff_setup_done(&rev
.diffopt
);
1318 head
= resolve_ref_unsafe("HEAD", junk_sha1
, 0, NULL
);
1320 !prefixcmp(head
, "refs/heads/") ?
1322 !strcmp(head
, "HEAD") ?
1323 _("detached HEAD") :
1325 initial_commit
? _(" (root-commit)") : "");
1327 if (!log_tree_commit(&rev
, commit
)) {
1328 rev
.always_show_header
= 1;
1329 rev
.use_terminator
= 1;
1330 log_tree_commit(&rev
, commit
);
1333 strbuf_release(&format
);
1336 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1338 struct wt_status
*s
= cb
;
1341 if (!strcmp(k
, "commit.template"))
1342 return git_config_pathname(&template_file
, k
, v
);
1343 if (!strcmp(k
, "commit.status")) {
1344 include_status
= git_config_bool(k
, v
);
1348 status
= git_gpg_config(k
, v
, NULL
);
1351 return git_status_config(k
, v
, s
);
1354 static const char post_rewrite_hook
[] = "hooks/post-rewrite";
1356 static int run_rewrite_hook(const unsigned char *oldsha1
,
1357 const unsigned char *newsha1
)
1359 /* oldsha1 SP newsha1 LF NUL */
1360 static char buf
[2*40 + 3];
1361 struct child_process proc
;
1362 const char *argv
[3];
1366 if (access(git_path(post_rewrite_hook
), X_OK
) < 0)
1369 argv
[0] = git_path(post_rewrite_hook
);
1373 memset(&proc
, 0, sizeof(proc
));
1376 proc
.stdout_to_stderr
= 1;
1378 code
= start_command(&proc
);
1381 n
= snprintf(buf
, sizeof(buf
), "%s %s\n",
1382 sha1_to_hex(oldsha1
), sha1_to_hex(newsha1
));
1383 write_in_full(proc
.in
, buf
, n
);
1385 return finish_command(&proc
);
1388 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1390 struct strbuf sb
= STRBUF_INIT
;
1391 struct strbuf author_ident
= STRBUF_INIT
;
1392 const char *index_file
, *reflog_msg
;
1394 unsigned char sha1
[20];
1395 struct ref_lock
*ref_lock
;
1396 struct commit_list
*parents
= NULL
, **pptr
= &parents
;
1397 struct stat statbuf
;
1398 int allow_fast_forward
= 1;
1400 struct commit
*current_head
= NULL
;
1401 struct commit_extra_header
*extra
= NULL
;
1403 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1404 usage_with_options(builtin_commit_usage
, builtin_commit_options
);
1406 wt_status_prepare(&s
);
1407 git_config(git_commit_config
, &s
);
1408 determine_whence(&s
);
1410 if (get_sha1("HEAD", sha1
))
1411 current_head
= NULL
;
1413 current_head
= lookup_commit_or_die(sha1
, "HEAD");
1414 if (!current_head
|| parse_commit(current_head
))
1415 die(_("could not parse HEAD commit"));
1417 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_usage
,
1418 prefix
, current_head
, &s
);
1420 return dry_run_commit(argc
, argv
, prefix
, current_head
, &s
);
1421 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 0);
1423 /* Set up everything for writing the commit object. This includes
1424 running hooks, writing the trees, and interacting with the user. */
1425 if (!prepare_to_commit(index_file
, prefix
,
1426 current_head
, &s
, &author_ident
)) {
1427 rollback_index_files();
1431 /* Determine parents */
1432 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1433 if (!current_head
) {
1435 reflog_msg
= "commit (initial)";
1437 struct commit_list
*c
;
1440 reflog_msg
= "commit (amend)";
1441 for (c
= current_head
->parents
; c
; c
= c
->next
)
1442 pptr
= &commit_list_insert(c
->item
, pptr
)->next
;
1443 } else if (whence
== FROM_MERGE
) {
1444 struct strbuf m
= STRBUF_INIT
;
1448 reflog_msg
= "commit (merge)";
1449 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1450 fp
= fopen(git_path("MERGE_HEAD"), "r");
1452 die_errno(_("could not open '%s' for reading"),
1453 git_path("MERGE_HEAD"));
1454 while (strbuf_getline(&m
, fp
, '\n') != EOF
) {
1455 struct commit
*parent
;
1457 parent
= get_merge_parent(m
.buf
);
1459 die(_("Corrupt MERGE_HEAD file (%s)"), m
.buf
);
1460 pptr
= &commit_list_insert(parent
, pptr
)->next
;
1464 if (!stat(git_path("MERGE_MODE"), &statbuf
)) {
1465 if (strbuf_read_file(&sb
, git_path("MERGE_MODE"), 0) < 0)
1466 die_errno(_("could not read MERGE_MODE"));
1467 if (!strcmp(sb
.buf
, "no-ff"))
1468 allow_fast_forward
= 0;
1470 if (allow_fast_forward
)
1471 parents
= reduce_heads(parents
);
1474 reflog_msg
= (whence
== FROM_CHERRY_PICK
)
1475 ? "commit (cherry-pick)"
1477 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1480 /* Finally, get the commit message */
1482 if (strbuf_read_file(&sb
, git_path(commit_editmsg
), 0) < 0) {
1483 int saved_errno
= errno
;
1484 rollback_index_files();
1485 die(_("could not read commit message: %s"), strerror(saved_errno
));
1488 /* Truncate the message just before the diff, if any. */
1490 p
= strstr(sb
.buf
, "\ndiff --git ");
1492 strbuf_setlen(&sb
, p
- sb
.buf
+ 1);
1495 if (cleanup_mode
!= CLEANUP_NONE
)
1496 stripspace(&sb
, cleanup_mode
== CLEANUP_ALL
);
1497 if (message_is_empty(&sb
) && !allow_empty_message
) {
1498 rollback_index_files();
1499 fprintf(stderr
, _("Aborting commit due to empty commit message.\n"));
1504 const char *exclude_gpgsig
[2] = { "gpgsig", NULL
};
1505 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1507 struct commit_extra_header
**tail
= &extra
;
1508 append_merge_tag_headers(parents
, &tail
);
1511 if (commit_tree_extended(&sb
, active_cache_tree
->sha1
, parents
, sha1
,
1512 author_ident
.buf
, sign_commit
, extra
)) {
1513 rollback_index_files();
1514 die(_("failed to write commit object"));
1516 strbuf_release(&author_ident
);
1517 free_commit_extra_headers(extra
);
1519 ref_lock
= lock_any_ref_for_update("HEAD",
1522 : current_head
->object
.sha1
,
1525 nl
= strchr(sb
.buf
, '\n');
1527 strbuf_setlen(&sb
, nl
+ 1 - sb
.buf
);
1529 strbuf_addch(&sb
, '\n');
1530 strbuf_insert(&sb
, 0, reflog_msg
, strlen(reflog_msg
));
1531 strbuf_insert(&sb
, strlen(reflog_msg
), ": ", 2);
1534 rollback_index_files();
1535 die(_("cannot lock HEAD ref"));
1537 if (write_ref_sha1(ref_lock
, sha1
, sb
.buf
) < 0) {
1538 rollback_index_files();
1539 die(_("cannot update HEAD ref"));
1542 unlink(git_path("CHERRY_PICK_HEAD"));
1543 unlink(git_path("REVERT_HEAD"));
1544 unlink(git_path("MERGE_HEAD"));
1545 unlink(git_path("MERGE_MSG"));
1546 unlink(git_path("MERGE_MODE"));
1547 unlink(git_path("SQUASH_MSG"));
1549 if (commit_index_files())
1550 die (_("Repository has been updated, but unable to write\n"
1551 "new_index file. Check that disk is not full or quota is\n"
1552 "not exceeded, and then \"git reset HEAD\" to recover."));
1555 run_hook(get_index_file(), "post-commit", NULL
);
1556 if (amend
&& !no_post_rewrite
) {
1557 struct notes_rewrite_cfg
*cfg
;
1558 cfg
= init_copy_notes_for_rewrite("amend");
1560 /* we are amending, so current_head is not NULL */
1561 copy_note_for_rewrite(cfg
, current_head
->object
.sha1
, sha1
);
1562 finish_copy_notes_for_rewrite(cfg
);
1564 run_rewrite_hook(current_head
->object
.sha1
, sha1
);
1567 print_summary(prefix
, sha1
, !current_head
);