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
;
117 STATUS_FORMAT_PORCELAIN
118 } status_format
= STATUS_FORMAT_LONG
;
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 void determine_whence(struct wt_status
*s
)
134 if (file_exists(git_path("MERGE_HEAD")))
136 else if (file_exists(git_path("CHERRY_PICK_HEAD")))
137 whence
= FROM_CHERRY_PICK
;
139 whence
= FROM_COMMIT
;
144 static void rollback_index_files(void)
146 switch (commit_style
) {
148 break; /* nothing to do */
150 rollback_lock_file(&index_lock
);
153 rollback_lock_file(&index_lock
);
154 rollback_lock_file(&false_lock
);
159 static int commit_index_files(void)
163 switch (commit_style
) {
165 break; /* nothing to do */
167 err
= commit_lock_file(&index_lock
);
170 err
= commit_lock_file(&index_lock
);
171 rollback_lock_file(&false_lock
);
179 * Take a union of paths in the index and the named tree (typically, "HEAD"),
180 * and return the paths that match the given pattern in list.
182 static int list_paths(struct string_list
*list
, const char *with_tree
,
183 const char *prefix
, const char **pattern
)
188 for (i
= 0; pattern
[i
]; i
++)
193 char *max_prefix
= common_prefix(pattern
);
194 overlay_tree_on_cache(with_tree
, max_prefix
? max_prefix
: prefix
);
198 for (i
= 0; i
< active_nr
; i
++) {
199 struct cache_entry
*ce
= active_cache
[i
];
200 struct string_list_item
*item
;
202 if (ce
->ce_flags
& CE_UPDATE
)
204 if (!match_pathspec(pattern
, ce
->name
, ce_namelen(ce
), 0, m
))
206 item
= string_list_insert(list
, ce
->name
);
207 if (ce_skip_worktree(ce
))
208 item
->util
= item
; /* better a valid pointer than a fake one */
211 return report_path_error(m
, pattern
, prefix
);
214 static void add_remove_files(struct string_list
*list
)
217 for (i
= 0; i
< list
->nr
; i
++) {
219 struct string_list_item
*p
= &(list
->items
[i
]);
221 /* p->util is skip-worktree */
225 if (!lstat(p
->string
, &st
)) {
226 if (add_to_cache(p
->string
, &st
, 0))
227 die(_("updating files failed"));
229 remove_file_from_cache(p
->string
);
233 static void create_base_index(const struct commit
*current_head
)
236 struct unpack_trees_options opts
;
244 memset(&opts
, 0, sizeof(opts
));
248 opts
.src_index
= &the_index
;
249 opts
.dst_index
= &the_index
;
251 opts
.fn
= oneway_merge
;
252 tree
= parse_tree_indirect(current_head
->object
.sha1
);
254 die(_("failed to unpack HEAD tree object"));
256 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
257 if (unpack_trees(1, &t
, &opts
))
258 exit(128); /* We've already reported the error, finish dying */
261 static void refresh_cache_or_die(int refresh_flags
)
264 * refresh_flags contains REFRESH_QUIET, so the only errors
265 * are for unmerged entries.
267 if (refresh_cache(refresh_flags
| REFRESH_IN_PORCELAIN
))
268 die_resolve_conflict("commit");
271 static char *prepare_index(int argc
, const char **argv
, const char *prefix
,
272 const struct commit
*current_head
, int is_status
)
275 struct string_list partial
;
276 const char **pathspec
= NULL
;
277 char *old_index_env
= NULL
;
278 int refresh_flags
= REFRESH_QUIET
;
281 refresh_flags
|= REFRESH_UNMERGED
;
284 pathspec
= get_pathspec(prefix
, argv
);
286 if (read_cache_preload(pathspec
) < 0)
287 die(_("index file corrupt"));
290 fd
= hold_locked_index(&index_lock
, 1);
292 refresh_cache_or_die(refresh_flags
);
294 if (write_cache(fd
, active_cache
, active_nr
) ||
295 close_lock_file(&index_lock
))
296 die(_("unable to create temporary index"));
298 old_index_env
= getenv(INDEX_ENVIRONMENT
);
299 setenv(INDEX_ENVIRONMENT
, index_lock
.filename
, 1);
301 if (interactive_add(argc
, argv
, prefix
, patch_interactive
) != 0)
302 die(_("interactive add failed"));
304 if (old_index_env
&& *old_index_env
)
305 setenv(INDEX_ENVIRONMENT
, old_index_env
, 1);
307 unsetenv(INDEX_ENVIRONMENT
);
310 read_cache_from(index_lock
.filename
);
312 commit_style
= COMMIT_NORMAL
;
313 return index_lock
.filename
;
317 * Non partial, non as-is commit.
319 * (1) get the real index;
320 * (2) update the_index as necessary;
321 * (3) write the_index out to the real index (still locked);
322 * (4) return the name of the locked index file.
324 * The caller should run hooks on the locked real index, and
325 * (A) if all goes well, commit the real index;
326 * (B) on failure, rollback the real index.
328 if (all
|| (also
&& pathspec
&& *pathspec
)) {
329 fd
= hold_locked_index(&index_lock
, 1);
330 add_files_to_cache(also
? prefix
: NULL
, pathspec
, 0);
331 refresh_cache_or_die(refresh_flags
);
332 update_main_cache_tree(WRITE_TREE_SILENT
);
333 if (write_cache(fd
, active_cache
, active_nr
) ||
334 close_lock_file(&index_lock
))
335 die(_("unable to write new_index file"));
336 commit_style
= COMMIT_NORMAL
;
337 return index_lock
.filename
;
343 * (1) return the name of the real index file.
345 * The caller should run hooks on the real index,
346 * and create commit from the_index.
347 * We still need to refresh the index here.
349 if (!pathspec
|| !*pathspec
) {
350 fd
= hold_locked_index(&index_lock
, 1);
351 refresh_cache_or_die(refresh_flags
);
352 if (active_cache_changed
) {
353 update_main_cache_tree(WRITE_TREE_SILENT
);
354 if (write_cache(fd
, active_cache
, active_nr
) ||
355 commit_locked_index(&index_lock
))
356 die(_("unable to write new_index file"));
358 rollback_lock_file(&index_lock
);
360 commit_style
= COMMIT_AS_IS
;
361 return get_index_file();
367 * (0) find the set of affected paths;
368 * (1) get lock on the real index file;
369 * (2) update the_index with the given paths;
370 * (3) write the_index out to the real index (still locked);
371 * (4) get lock on the false index file;
372 * (5) reset the_index from HEAD;
373 * (6) update the_index the same way as (2);
374 * (7) write the_index out to the false index file;
375 * (8) return the name of the false index file (still locked);
377 * The caller should run hooks on the locked false index, and
378 * create commit from it. Then
379 * (A) if all goes well, commit the real index;
380 * (B) on failure, rollback the real index;
381 * In either case, rollback the false index.
383 commit_style
= COMMIT_PARTIAL
;
385 if (whence
!= FROM_COMMIT
) {
386 if (whence
== FROM_MERGE
)
387 die(_("cannot do a partial commit during a merge."));
388 else if (whence
== FROM_CHERRY_PICK
)
389 die(_("cannot do a partial commit during a cherry-pick."));
392 memset(&partial
, 0, sizeof(partial
));
393 partial
.strdup_strings
= 1;
394 if (list_paths(&partial
, !current_head
? NULL
: "HEAD", prefix
, pathspec
))
398 if (read_cache() < 0)
399 die(_("cannot read the index"));
401 fd
= hold_locked_index(&index_lock
, 1);
402 add_remove_files(&partial
);
403 refresh_cache(REFRESH_QUIET
);
404 if (write_cache(fd
, active_cache
, active_nr
) ||
405 close_lock_file(&index_lock
))
406 die(_("unable to write new_index file"));
408 fd
= hold_lock_file_for_update(&false_lock
,
409 git_path("next-index-%"PRIuMAX
,
410 (uintmax_t) getpid()),
413 create_base_index(current_head
);
414 add_remove_files(&partial
);
415 refresh_cache(REFRESH_QUIET
);
417 if (write_cache(fd
, active_cache
, active_nr
) ||
418 close_lock_file(&false_lock
))
419 die(_("unable to write temporary index file"));
422 read_cache_from(false_lock
.filename
);
424 return false_lock
.filename
;
427 static int run_status(FILE *fp
, const char *index_file
, const char *prefix
, int nowarn
,
430 unsigned char sha1
[20];
432 if (s
->relative_paths
)
437 s
->reference
= "HEAD^1";
439 s
->verbose
= verbose
;
440 s
->index_file
= index_file
;
443 s
->is_initial
= get_sha1(s
->reference
, sha1
) ? 1 : 0;
445 wt_status_collect(s
);
447 switch (status_format
) {
448 case STATUS_FORMAT_SHORT
:
449 wt_shortstatus_print(s
);
451 case STATUS_FORMAT_PORCELAIN
:
452 wt_porcelain_print(s
);
454 case STATUS_FORMAT_LONG
:
459 return s
->commitable
;
462 static int is_a_merge(const struct commit
*current_head
)
464 return !!(current_head
->parents
&& current_head
->parents
->next
);
467 static const char sign_off_header
[] = "Signed-off-by: ";
469 static void export_one(const char *var
, const char *s
, const char *e
, int hack
)
471 struct strbuf buf
= STRBUF_INIT
;
473 strbuf_addch(&buf
, hack
);
474 strbuf_addf(&buf
, "%.*s", (int)(e
- s
), s
);
475 setenv(var
, buf
.buf
, 1);
476 strbuf_release(&buf
);
479 static void determine_author_info(struct strbuf
*author_ident
)
481 char *name
, *email
, *date
;
482 struct ident_split author
;
484 name
= getenv("GIT_AUTHOR_NAME");
485 email
= getenv("GIT_AUTHOR_EMAIL");
486 date
= getenv("GIT_AUTHOR_DATE");
488 if (author_message
) {
489 const char *a
, *lb
, *rb
, *eol
;
492 a
= strstr(author_message_buffer
, "\nauthor ");
494 die(_("invalid commit: %s"), author_message
);
496 lb
= strchrnul(a
+ strlen("\nauthor "), '<');
497 rb
= strchrnul(lb
, '>');
498 eol
= strchrnul(rb
, '\n');
499 if (!*lb
|| !*rb
|| !*eol
)
500 die(_("invalid commit: %s"), author_message
);
502 if (lb
== a
+ strlen("\nauthor "))
503 /* \nauthor <foo@example.com> */
504 name
= xcalloc(1, 1);
506 name
= xmemdupz(a
+ strlen("\nauthor "),
508 (a
+ strlen("\nauthor "))));
509 email
= xmemdupz(lb
+ strlen("<"), rb
- (lb
+ strlen("<")));
510 date
= xmemdupz(rb
+ strlen("> "), eol
- (rb
+ strlen("> ")));
511 len
= eol
- (rb
+ strlen("> "));
512 date
= xmalloc(len
+ 2);
514 memcpy(date
+ 1, rb
+ strlen("> "), len
);
515 date
[len
+ 1] = '\0';
519 const char *lb
= strstr(force_author
, " <");
520 const char *rb
= strchr(force_author
, '>');
523 die(_("malformed --author parameter"));
524 name
= xstrndup(force_author
, lb
- force_author
);
525 email
= xstrndup(lb
+ 2, rb
- (lb
+ 2));
530 strbuf_addstr(author_ident
, fmt_ident(name
, email
, date
,
531 IDENT_ERROR_ON_NO_NAME
));
532 if (!split_ident_line(&author
, author_ident
->buf
, author_ident
->len
)) {
533 export_one("GIT_AUTHOR_NAME", author
.name_begin
, author
.name_end
, 0);
534 export_one("GIT_AUTHOR_EMAIL", author
.mail_begin
, author
.mail_end
, 0);
535 export_one("GIT_AUTHOR_DATE", author
.date_begin
, author
.tz_end
, '@');
539 static int ends_rfc2822_footer(struct strbuf
*sb
)
546 const char *buf
= sb
->buf
;
548 for (i
= len
- 1; i
> 0; i
--) {
549 if (hit
&& buf
[i
] == '\n')
551 hit
= (buf
[i
] == '\n');
554 while (i
< len
- 1 && buf
[i
] == '\n')
557 for (; i
< len
; i
= k
) {
558 for (k
= i
; k
< len
&& buf
[k
] != '\n'; k
++)
562 if ((buf
[k
] == ' ' || buf
[k
] == '\t') && !first
)
567 for (j
= 0; i
+ j
< len
; j
++) {
580 static char *cut_ident_timestamp_part(char *string
)
582 char *ket
= strrchr(string
, '>');
583 if (!ket
|| ket
[1] != ' ')
584 die(_("Malformed ident string: '%s'"), string
);
589 static int prepare_to_commit(const char *index_file
, const char *prefix
,
590 struct commit
*current_head
,
592 struct strbuf
*author_ident
)
595 struct strbuf committer_ident
= STRBUF_INIT
;
596 int commitable
, saved_color_setting
;
597 struct strbuf sb
= STRBUF_INIT
;
599 const char *hook_arg1
= NULL
;
600 const char *hook_arg2
= NULL
;
602 int clean_message_contents
= (cleanup_mode
!= CLEANUP_NONE
);
604 /* This checks and barfs if author is badly specified */
605 determine_author_info(author_ident
);
607 if (!no_verify
&& run_hook(index_file
, "pre-commit", NULL
))
610 if (squash_message
) {
612 * Insert the proper subject line before other commit
613 * message options add their content.
615 if (use_message
&& !strcmp(use_message
, squash_message
))
616 strbuf_addstr(&sb
, "squash! ");
618 struct pretty_print_context ctx
= {0};
620 c
= lookup_commit_reference_by_name(squash_message
);
622 die(_("could not lookup commit %s"), squash_message
);
623 ctx
.output_encoding
= get_commit_output_encoding();
624 format_commit_message(c
, "squash! %s\n\n", &sb
,
630 strbuf_addbuf(&sb
, &message
);
631 hook_arg1
= "message";
632 } else if (logfile
&& !strcmp(logfile
, "-")) {
634 fprintf(stderr
, _("(reading log message from standard input)\n"));
635 if (strbuf_read(&sb
, 0, 0) < 0)
636 die_errno(_("could not read log from standard input"));
637 hook_arg1
= "message";
638 } else if (logfile
) {
639 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
640 die_errno(_("could not read log file '%s'"),
642 hook_arg1
= "message";
643 } else if (use_message
) {
644 buffer
= strstr(use_message_buffer
, "\n\n");
645 if (!buffer
|| buffer
[2] == '\0')
646 die(_("commit has empty message"));
647 strbuf_add(&sb
, buffer
+ 2, strlen(buffer
+ 2));
648 hook_arg1
= "commit";
649 hook_arg2
= use_message
;
650 } else if (fixup_message
) {
651 struct pretty_print_context ctx
= {0};
652 struct commit
*commit
;
653 commit
= lookup_commit_reference_by_name(fixup_message
);
655 die(_("could not lookup commit %s"), fixup_message
);
656 ctx
.output_encoding
= get_commit_output_encoding();
657 format_commit_message(commit
, "fixup! %s\n\n",
659 hook_arg1
= "message";
660 } else if (!stat(git_path("MERGE_MSG"), &statbuf
)) {
661 if (strbuf_read_file(&sb
, git_path("MERGE_MSG"), 0) < 0)
662 die_errno(_("could not read MERGE_MSG"));
664 } else if (!stat(git_path("SQUASH_MSG"), &statbuf
)) {
665 if (strbuf_read_file(&sb
, git_path("SQUASH_MSG"), 0) < 0)
666 die_errno(_("could not read SQUASH_MSG"));
667 hook_arg1
= "squash";
668 } else if (template_file
) {
669 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
670 die_errno(_("could not read '%s'"), template_file
);
671 hook_arg1
= "template";
672 clean_message_contents
= 0;
676 * The remaining cases don't modify the template message, but
677 * just set the argument(s) to the prepare-commit-msg hook.
679 else if (whence
== FROM_MERGE
)
681 else if (whence
== FROM_CHERRY_PICK
) {
682 hook_arg1
= "commit";
683 hook_arg2
= "CHERRY_PICK_HEAD";
686 if (squash_message
) {
688 * If squash_commit was used for the commit subject,
689 * then we're possibly hijacking other commit log options.
690 * Reset the hook args to tell the real story.
692 hook_arg1
= "message";
696 s
->fp
= fopen(git_path(commit_editmsg
), "w");
698 die_errno(_("could not open '%s'"), git_path(commit_editmsg
));
700 if (clean_message_contents
)
704 struct strbuf sob
= STRBUF_INIT
;
707 strbuf_addstr(&sob
, sign_off_header
);
708 strbuf_addstr(&sob
, fmt_name(getenv("GIT_COMMITTER_NAME"),
709 getenv("GIT_COMMITTER_EMAIL")));
710 strbuf_addch(&sob
, '\n');
711 for (i
= sb
.len
- 1; i
> 0 && sb
.buf
[i
- 1] != '\n'; i
--)
713 if (prefixcmp(sb
.buf
+ i
, sob
.buf
)) {
714 if (!i
|| !ends_rfc2822_footer(&sb
))
715 strbuf_addch(&sb
, '\n');
716 strbuf_addbuf(&sb
, &sob
);
718 strbuf_release(&sob
);
721 if (fwrite(sb
.buf
, 1, sb
.len
, s
->fp
) < sb
.len
)
722 die_errno(_("could not write commit template"));
726 /* This checks if committer ident is explicitly given */
727 strbuf_addstr(&committer_ident
, git_committer_info(0));
728 if (use_editor
&& include_status
) {
729 char *ai_tmp
, *ci_tmp
;
730 if (whence
!= FROM_COMMIT
)
731 status_printf_ln(s
, GIT_COLOR_NORMAL
,
734 "It looks like you may be committing a merge.\n"
735 "If this is not correct, please remove the file\n"
739 "It looks like you may be committing a cherry-pick.\n"
740 "If this is not correct, please remove the file\n"
743 git_path(whence
== FROM_MERGE
745 : "CHERRY_PICK_HEAD"));
747 fprintf(s
->fp
, "\n");
748 if (cleanup_mode
== CLEANUP_ALL
)
749 status_printf(s
, GIT_COLOR_NORMAL
,
750 _("Please enter the commit message for your changes."
751 " Lines starting\nwith '#' will be ignored, and an empty"
752 " message aborts the commit.\n"));
753 else /* CLEANUP_SPACE, that is. */
754 status_printf(s
, GIT_COLOR_NORMAL
,
755 _("Please enter the commit message for your changes."
757 "with '#' will be kept; you may remove them"
758 " yourself if you want to.\n"
759 "An empty message aborts the commit.\n"));
760 if (only_include_assumed
)
761 status_printf_ln(s
, GIT_COLOR_NORMAL
,
762 "%s", only_include_assumed
);
764 ai_tmp
= cut_ident_timestamp_part(author_ident
->buf
);
765 ci_tmp
= cut_ident_timestamp_part(committer_ident
.buf
);
766 if (strcmp(author_ident
->buf
, committer_ident
.buf
))
767 status_printf_ln(s
, GIT_COLOR_NORMAL
,
770 ident_shown
++ ? "" : "\n",
773 if (!user_ident_sufficiently_given())
774 status_printf_ln(s
, GIT_COLOR_NORMAL
,
777 ident_shown
++ ? "" : "\n",
778 committer_ident
.buf
);
781 status_printf_ln(s
, GIT_COLOR_NORMAL
, "");
783 saved_color_setting
= s
->use_color
;
785 commitable
= run_status(s
->fp
, index_file
, prefix
, 1, s
);
786 s
->use_color
= saved_color_setting
;
791 unsigned char sha1
[20];
792 const char *parent
= "HEAD";
794 if (!active_nr
&& read_cache() < 0)
795 die(_("Cannot read index"));
800 if (get_sha1(parent
, sha1
))
801 commitable
= !!active_nr
;
803 commitable
= index_differs_from(parent
, 0);
805 strbuf_release(&committer_ident
);
810 * Reject an attempt to record a non-merge empty commit without
811 * explicit --allow-empty. In the cherry-pick case, it may be
812 * empty due to conflict resolution, which the user should okay.
814 if (!commitable
&& whence
!= FROM_MERGE
&& !allow_empty
&&
815 !(amend
&& is_a_merge(current_head
))) {
816 run_status(stdout
, index_file
, prefix
, 0, s
);
818 fputs(_(empty_amend_advice
), stderr
);
819 else if (whence
== FROM_CHERRY_PICK
)
820 fputs(_(empty_cherry_pick_advice
), stderr
);
825 * Re-read the index as pre-commit hook could have updated it,
826 * and write it out as a tree. We must do this before we invoke
827 * the editor and after we invoke run_status above.
830 read_cache_from(index_file
);
831 if (update_main_cache_tree(0)) {
832 error(_("Error building trees"));
836 if (run_hook(index_file
, "prepare-commit-msg",
837 git_path(commit_editmsg
), hook_arg1
, hook_arg2
, NULL
))
841 char index
[PATH_MAX
];
842 const char *env
[2] = { NULL
};
844 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
845 if (launch_editor(git_path(commit_editmsg
), NULL
, env
)) {
847 _("Please supply the message using either -m or -F option.\n"));
853 run_hook(index_file
, "commit-msg", git_path(commit_editmsg
), NULL
)) {
860 static int rest_is_empty(struct strbuf
*sb
, int start
)
865 /* Check if the rest is just whitespace and Signed-of-by's. */
866 for (i
= start
; i
< sb
->len
; i
++) {
867 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
873 if (strlen(sign_off_header
) <= eol
- i
&&
874 !prefixcmp(sb
->buf
+ i
, sign_off_header
)) {
879 if (!isspace(sb
->buf
[i
++]))
887 * Find out if the message in the strbuf contains only whitespace and
888 * Signed-off-by lines.
890 static int message_is_empty(struct strbuf
*sb
)
892 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
894 return rest_is_empty(sb
, 0);
898 * See if the user edited the message in the editor or left what
899 * was in the template intact
901 static int template_untouched(struct strbuf
*sb
)
903 struct strbuf tmpl
= STRBUF_INIT
;
906 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
909 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
912 stripspace(&tmpl
, cleanup_mode
== CLEANUP_ALL
);
913 start
= (char *)skip_prefix(sb
->buf
, tmpl
.buf
);
916 strbuf_release(&tmpl
);
917 return rest_is_empty(sb
, start
- sb
->buf
);
920 static const char *find_author_by_nickname(const char *name
)
922 struct rev_info revs
;
923 struct commit
*commit
;
924 struct strbuf buf
= STRBUF_INIT
;
928 init_revisions(&revs
, NULL
);
929 strbuf_addf(&buf
, "--author=%s", name
);
934 setup_revisions(ac
, av
, &revs
, NULL
);
935 prepare_revision_walk(&revs
);
936 commit
= get_revision(&revs
);
938 struct pretty_print_context ctx
= {0};
939 ctx
.date_mode
= DATE_NORMAL
;
940 strbuf_release(&buf
);
941 format_commit_message(commit
, "%an <%ae>", &buf
, &ctx
);
942 return strbuf_detach(&buf
, NULL
);
944 die(_("No existing author found with '%s'"), name
);
948 static void handle_untracked_files_arg(struct wt_status
*s
)
950 if (!untracked_files_arg
)
951 ; /* default already initialized */
952 else if (!strcmp(untracked_files_arg
, "no"))
953 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
954 else if (!strcmp(untracked_files_arg
, "normal"))
955 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
956 else if (!strcmp(untracked_files_arg
, "all"))
957 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
959 die(_("Invalid untracked files mode '%s'"), untracked_files_arg
);
962 static const char *read_commit_message(const char *name
)
964 const char *out_enc
, *out
;
965 struct commit
*commit
;
967 commit
= lookup_commit_reference_by_name(name
);
969 die(_("could not lookup commit %s"), name
);
970 out_enc
= get_commit_output_encoding();
971 out
= logmsg_reencode(commit
, out_enc
);
974 * If we failed to reencode the buffer, just copy it
975 * byte for byte so the user can try to fix it up.
976 * This also handles the case where input and output
977 * encodings are identical.
980 out
= xstrdup(commit
->buffer
);
984 static int parse_and_validate_options(int argc
, const char *argv
[],
985 const struct option
*options
,
986 const char * const usage
[],
988 struct commit
*current_head
,
993 argc
= parse_options(argc
, argv
, prefix
, options
, usage
, 0);
995 if (force_author
&& !strchr(force_author
, '>'))
996 force_author
= find_author_by_nickname(force_author
);
998 if (force_author
&& renew_authorship
)
999 die(_("Using both --reset-author and --author does not make sense"));
1001 if (logfile
|| message
.len
|| use_message
|| fixup_message
)
1004 use_editor
= edit_flag
;
1006 setenv("GIT_EDITOR", ":", 1);
1008 /* Sanity check options */
1009 if (amend
&& !current_head
)
1010 die(_("You have nothing to amend."));
1011 if (amend
&& whence
!= FROM_COMMIT
) {
1012 if (whence
== FROM_MERGE
)
1013 die(_("You are in the middle of a merge -- cannot amend."));
1014 else if (whence
== FROM_CHERRY_PICK
)
1015 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1017 if (fixup_message
&& squash_message
)
1018 die(_("Options --squash and --fixup cannot be used together"));
1028 die(_("Only one of -c/-C/-F/--fixup can be used."));
1029 if (message
.len
&& f
> 0)
1030 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1031 if (f
|| message
.len
)
1032 template_file
= NULL
;
1034 use_message
= edit_message
;
1035 if (amend
&& !use_message
&& !fixup_message
)
1036 use_message
= "HEAD";
1037 if (!use_message
&& whence
!= FROM_CHERRY_PICK
&& renew_authorship
)
1038 die(_("--reset-author can be used only with -C, -c or --amend."));
1040 use_message_buffer
= read_commit_message(use_message
);
1041 if (!renew_authorship
) {
1042 author_message
= use_message
;
1043 author_message_buffer
= use_message_buffer
;
1046 if (whence
== FROM_CHERRY_PICK
&& !renew_authorship
) {
1047 author_message
= "CHERRY_PICK_HEAD";
1048 author_message_buffer
= read_commit_message(author_message
);
1051 if (patch_interactive
)
1054 if (!!also
+ !!only
+ !!all
+ !!interactive
> 1)
1055 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1056 if (argc
== 0 && (also
|| (only
&& !amend
)))
1057 die(_("No paths with --include/--only does not make sense."));
1058 if (argc
== 0 && only
&& amend
)
1059 only_include_assumed
= _("Clever... amending the last one with dirty index.");
1060 if (argc
> 0 && !also
&& !only
)
1061 only_include_assumed
= _("Explicit paths specified without -i nor -o; assuming --only paths...");
1062 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
1063 cleanup_mode
= use_editor
? CLEANUP_ALL
: CLEANUP_SPACE
;
1064 else if (!strcmp(cleanup_arg
, "verbatim"))
1065 cleanup_mode
= CLEANUP_NONE
;
1066 else if (!strcmp(cleanup_arg
, "whitespace"))
1067 cleanup_mode
= CLEANUP_SPACE
;
1068 else if (!strcmp(cleanup_arg
, "strip"))
1069 cleanup_mode
= CLEANUP_ALL
;
1071 die(_("Invalid cleanup mode %s"), cleanup_arg
);
1073 handle_untracked_files_arg(s
);
1075 if (all
&& argc
> 0)
1076 die(_("Paths with -a does not make sense."));
1078 if (s
->null_termination
&& status_format
== STATUS_FORMAT_LONG
)
1079 status_format
= STATUS_FORMAT_PORCELAIN
;
1080 if (status_format
!= STATUS_FORMAT_LONG
)
1086 static int dry_run_commit(int argc
, const char **argv
, const char *prefix
,
1087 const struct commit
*current_head
, struct wt_status
*s
)
1090 const char *index_file
;
1092 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 1);
1093 commitable
= run_status(stdout
, index_file
, prefix
, 0, s
);
1094 rollback_index_files();
1096 return commitable
? 0 : 1;
1099 static int parse_status_slot(const char *var
, int offset
)
1101 if (!strcasecmp(var
+offset
, "header"))
1102 return WT_STATUS_HEADER
;
1103 if (!strcasecmp(var
+offset
, "branch"))
1104 return WT_STATUS_ONBRANCH
;
1105 if (!strcasecmp(var
+offset
, "updated")
1106 || !strcasecmp(var
+offset
, "added"))
1107 return WT_STATUS_UPDATED
;
1108 if (!strcasecmp(var
+offset
, "changed"))
1109 return WT_STATUS_CHANGED
;
1110 if (!strcasecmp(var
+offset
, "untracked"))
1111 return WT_STATUS_UNTRACKED
;
1112 if (!strcasecmp(var
+offset
, "nobranch"))
1113 return WT_STATUS_NOBRANCH
;
1114 if (!strcasecmp(var
+offset
, "unmerged"))
1115 return WT_STATUS_UNMERGED
;
1119 static int git_status_config(const char *k
, const char *v
, void *cb
)
1121 struct wt_status
*s
= cb
;
1123 if (!prefixcmp(k
, "column."))
1124 return git_column_config(k
, v
, "status", &colopts
);
1125 if (!strcmp(k
, "status.submodulesummary")) {
1127 s
->submodule_summary
= git_config_bool_or_int(k
, v
, &is_bool
);
1128 if (is_bool
&& s
->submodule_summary
)
1129 s
->submodule_summary
= -1;
1132 if (!strcmp(k
, "status.color") || !strcmp(k
, "color.status")) {
1133 s
->use_color
= git_config_colorbool(k
, v
);
1136 if (!prefixcmp(k
, "status.color.") || !prefixcmp(k
, "color.status.")) {
1137 int slot
= parse_status_slot(k
, 13);
1141 return config_error_nonbool(k
);
1142 color_parse(v
, k
, s
->color_palette
[slot
]);
1145 if (!strcmp(k
, "status.relativepaths")) {
1146 s
->relative_paths
= git_config_bool(k
, v
);
1149 if (!strcmp(k
, "status.showuntrackedfiles")) {
1151 return config_error_nonbool(k
);
1152 else if (!strcmp(v
, "no"))
1153 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1154 else if (!strcmp(v
, "normal"))
1155 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1156 else if (!strcmp(v
, "all"))
1157 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1159 return error(_("Invalid untracked files mode '%s'"), v
);
1162 return git_diff_ui_config(k
, v
, NULL
);
1165 int cmd_status(int argc
, const char **argv
, const char *prefix
)
1167 static struct wt_status s
;
1169 unsigned char sha1
[20];
1170 static struct option builtin_status_options
[] = {
1171 OPT__VERBOSE(&verbose
, "be verbose"),
1172 OPT_SET_INT('s', "short", &status_format
,
1173 "show status concisely", STATUS_FORMAT_SHORT
),
1174 OPT_BOOLEAN('b', "branch", &s
.show_branch
,
1175 "show branch information"),
1176 OPT_SET_INT(0, "porcelain", &status_format
,
1177 "machine-readable output",
1178 STATUS_FORMAT_PORCELAIN
),
1179 OPT_BOOLEAN('z', "null", &s
.null_termination
,
1180 "terminate entries with NUL"),
1181 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
,
1183 "show untracked files, optional modes: all, normal, no. (Default: all)",
1184 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1185 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status
,
1186 "show ignored files"),
1187 { OPTION_STRING
, 0, "ignore-submodules", &ignore_submodule_arg
, "when",
1188 "ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)",
1189 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1190 OPT_COLUMN(0, "column", &colopts
, "list untracked files in columns"),
1194 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1195 usage_with_options(builtin_status_usage
, builtin_status_options
);
1197 wt_status_prepare(&s
);
1198 gitmodules_config();
1199 git_config(git_status_config
, &s
);
1200 determine_whence(&s
);
1201 argc
= parse_options(argc
, argv
, prefix
,
1202 builtin_status_options
,
1203 builtin_status_usage
, 0);
1204 finalize_colopts(&colopts
, -1);
1205 s
.colopts
= colopts
;
1207 if (s
.null_termination
&& status_format
== STATUS_FORMAT_LONG
)
1208 status_format
= STATUS_FORMAT_PORCELAIN
;
1210 handle_untracked_files_arg(&s
);
1211 if (show_ignored_in_status
)
1212 s
.show_ignored_files
= 1;
1214 s
.pathspec
= get_pathspec(prefix
, argv
);
1216 read_cache_preload(s
.pathspec
);
1217 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, s
.pathspec
, NULL
, NULL
);
1219 fd
= hold_locked_index(&index_lock
, 0);
1221 update_index_if_able(&the_index
, &index_lock
);
1223 s
.is_initial
= get_sha1(s
.reference
, sha1
) ? 1 : 0;
1224 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1225 wt_status_collect(&s
);
1227 if (s
.relative_paths
)
1230 switch (status_format
) {
1231 case STATUS_FORMAT_SHORT
:
1232 wt_shortstatus_print(&s
);
1234 case STATUS_FORMAT_PORCELAIN
:
1235 wt_porcelain_print(&s
);
1237 case STATUS_FORMAT_LONG
:
1238 s
.verbose
= verbose
;
1239 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1240 wt_status_print(&s
);
1246 static void print_summary(const char *prefix
, const unsigned char *sha1
,
1249 struct rev_info rev
;
1250 struct commit
*commit
;
1251 struct strbuf format
= STRBUF_INIT
;
1252 unsigned char junk_sha1
[20];
1254 struct pretty_print_context pctx
= {0};
1255 struct strbuf author_ident
= STRBUF_INIT
;
1256 struct strbuf committer_ident
= STRBUF_INIT
;
1258 commit
= lookup_commit(sha1
);
1260 die(_("couldn't look up newly created commit"));
1261 if (!commit
|| parse_commit(commit
))
1262 die(_("could not parse newly created commit"));
1264 strbuf_addstr(&format
, "format:%h] %s");
1266 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1267 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1268 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1269 strbuf_addstr(&format
, "\n Author: ");
1270 strbuf_addbuf_percentquote(&format
, &author_ident
);
1272 if (!user_ident_sufficiently_given()) {
1273 strbuf_addstr(&format
, "\n Committer: ");
1274 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1275 if (advice_implicit_identity
) {
1276 strbuf_addch(&format
, '\n');
1277 strbuf_addstr(&format
, _(implicit_ident_advice
));
1280 strbuf_release(&author_ident
);
1281 strbuf_release(&committer_ident
);
1283 init_revisions(&rev
, prefix
);
1284 setup_revisions(0, NULL
, &rev
, NULL
);
1287 rev
.diffopt
.output_format
=
1288 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1290 rev
.verbose_header
= 1;
1291 rev
.show_root_diff
= 1;
1292 get_commit_format(format
.buf
, &rev
);
1293 rev
.always_show_header
= 0;
1294 rev
.diffopt
.detect_rename
= 1;
1295 rev
.diffopt
.break_opt
= 0;
1296 diff_setup_done(&rev
.diffopt
);
1298 head
= resolve_ref_unsafe("HEAD", junk_sha1
, 0, NULL
);
1300 !prefixcmp(head
, "refs/heads/") ?
1302 !strcmp(head
, "HEAD") ?
1303 _("detached HEAD") :
1305 initial_commit
? _(" (root-commit)") : "");
1307 if (!log_tree_commit(&rev
, commit
)) {
1308 rev
.always_show_header
= 1;
1309 rev
.use_terminator
= 1;
1310 log_tree_commit(&rev
, commit
);
1313 strbuf_release(&format
);
1316 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1318 struct wt_status
*s
= cb
;
1321 if (!strcmp(k
, "commit.template"))
1322 return git_config_pathname(&template_file
, k
, v
);
1323 if (!strcmp(k
, "commit.status")) {
1324 include_status
= git_config_bool(k
, v
);
1328 status
= git_gpg_config(k
, v
, NULL
);
1331 return git_status_config(k
, v
, s
);
1334 static const char post_rewrite_hook
[] = "hooks/post-rewrite";
1336 static int run_rewrite_hook(const unsigned char *oldsha1
,
1337 const unsigned char *newsha1
)
1339 /* oldsha1 SP newsha1 LF NUL */
1340 static char buf
[2*40 + 3];
1341 struct child_process proc
;
1342 const char *argv
[3];
1346 if (access(git_path(post_rewrite_hook
), X_OK
) < 0)
1349 argv
[0] = git_path(post_rewrite_hook
);
1353 memset(&proc
, 0, sizeof(proc
));
1356 proc
.stdout_to_stderr
= 1;
1358 code
= start_command(&proc
);
1361 n
= snprintf(buf
, sizeof(buf
), "%s %s\n",
1362 sha1_to_hex(oldsha1
), sha1_to_hex(newsha1
));
1363 write_in_full(proc
.in
, buf
, n
);
1365 return finish_command(&proc
);
1368 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1370 static struct wt_status s
;
1371 static struct option builtin_commit_options
[] = {
1372 OPT__QUIET(&quiet
, "suppress summary after successful commit"),
1373 OPT__VERBOSE(&verbose
, "show diff in commit message template"),
1375 OPT_GROUP("Commit message options"),
1376 OPT_FILENAME('F', "file", &logfile
, "read message from file"),
1377 OPT_STRING(0, "author", &force_author
, "author", "override author for commit"),
1378 OPT_STRING(0, "date", &force_date
, "date", "override date for commit"),
1379 OPT_CALLBACK('m', "message", &message
, "message", "commit message", opt_parse_m
),
1380 OPT_STRING('c', "reedit-message", &edit_message
, "commit", "reuse and edit message from specified commit"),
1381 OPT_STRING('C', "reuse-message", &use_message
, "commit", "reuse message from specified commit"),
1382 OPT_STRING(0, "fixup", &fixup_message
, "commit", "use autosquash formatted message to fixup specified commit"),
1383 OPT_STRING(0, "squash", &squash_message
, "commit", "use autosquash formatted message to squash specified commit"),
1384 OPT_BOOLEAN(0, "reset-author", &renew_authorship
, "the commit is authored by me now (used with -C/-c/--amend)"),
1385 OPT_BOOLEAN('s', "signoff", &signoff
, "add Signed-off-by:"),
1386 OPT_FILENAME('t', "template", &template_file
, "use specified template file"),
1387 OPT_BOOL('e', "edit", &edit_flag
, "force edit of commit"),
1388 OPT_STRING(0, "cleanup", &cleanup_arg
, "default", "how to strip spaces and #comments from message"),
1389 OPT_BOOLEAN(0, "status", &include_status
, "include status in commit message template"),
1390 { OPTION_STRING
, 'S', "gpg-sign", &sign_commit
, "key id",
1391 "GPG sign commit", PARSE_OPT_OPTARG
, NULL
, (intptr_t) "" },
1392 /* end commit message options */
1394 OPT_GROUP("Commit contents options"),
1395 OPT_BOOLEAN('a', "all", &all
, "commit all changed files"),
1396 OPT_BOOLEAN('i', "include", &also
, "add specified files to index for commit"),
1397 OPT_BOOLEAN(0, "interactive", &interactive
, "interactively add files"),
1398 OPT_BOOLEAN('p', "patch", &patch_interactive
, "interactively add changes"),
1399 OPT_BOOLEAN('o', "only", &only
, "commit only specified files"),
1400 OPT_BOOLEAN('n', "no-verify", &no_verify
, "bypass pre-commit hook"),
1401 OPT_BOOLEAN(0, "dry-run", &dry_run
, "show what would be committed"),
1402 OPT_SET_INT(0, "short", &status_format
, "show status concisely",
1403 STATUS_FORMAT_SHORT
),
1404 OPT_BOOLEAN(0, "branch", &s
.show_branch
, "show branch information"),
1405 OPT_SET_INT(0, "porcelain", &status_format
,
1406 "machine-readable output", STATUS_FORMAT_PORCELAIN
),
1407 OPT_BOOLEAN('z', "null", &s
.null_termination
,
1408 "terminate entries with NUL"),
1409 OPT_BOOLEAN(0, "amend", &amend
, "amend previous commit"),
1410 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite
, "bypass post-rewrite hook"),
1411 { 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" },
1412 /* end commit contents options */
1414 { OPTION_BOOLEAN
, 0, "allow-empty", &allow_empty
, NULL
,
1415 "ok to record an empty change",
1416 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
1417 { OPTION_BOOLEAN
, 0, "allow-empty-message", &allow_empty_message
, NULL
,
1418 "ok to record a change with an empty message",
1419 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
1424 struct strbuf sb
= STRBUF_INIT
;
1425 struct strbuf author_ident
= STRBUF_INIT
;
1426 const char *index_file
, *reflog_msg
;
1428 unsigned char sha1
[20];
1429 struct ref_lock
*ref_lock
;
1430 struct commit_list
*parents
= NULL
, **pptr
= &parents
;
1431 struct stat statbuf
;
1432 int allow_fast_forward
= 1;
1433 struct commit
*current_head
= NULL
;
1434 struct commit_extra_header
*extra
= NULL
;
1436 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1437 usage_with_options(builtin_commit_usage
, builtin_commit_options
);
1439 wt_status_prepare(&s
);
1440 git_config(git_commit_config
, &s
);
1441 determine_whence(&s
);
1443 if (get_sha1("HEAD", sha1
))
1444 current_head
= NULL
;
1446 current_head
= lookup_commit_or_die(sha1
, "HEAD");
1447 if (!current_head
|| parse_commit(current_head
))
1448 die(_("could not parse HEAD commit"));
1450 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_options
,
1451 builtin_commit_usage
,
1452 prefix
, current_head
, &s
);
1454 return dry_run_commit(argc
, argv
, prefix
, current_head
, &s
);
1455 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 0);
1457 /* Set up everything for writing the commit object. This includes
1458 running hooks, writing the trees, and interacting with the user. */
1459 if (!prepare_to_commit(index_file
, prefix
,
1460 current_head
, &s
, &author_ident
)) {
1461 rollback_index_files();
1465 /* Determine parents */
1466 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1467 if (!current_head
) {
1469 reflog_msg
= "commit (initial)";
1471 struct commit_list
*c
;
1474 reflog_msg
= "commit (amend)";
1475 for (c
= current_head
->parents
; c
; c
= c
->next
)
1476 pptr
= &commit_list_insert(c
->item
, pptr
)->next
;
1477 } else if (whence
== FROM_MERGE
) {
1478 struct strbuf m
= STRBUF_INIT
;
1482 reflog_msg
= "commit (merge)";
1483 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1484 fp
= fopen(git_path("MERGE_HEAD"), "r");
1486 die_errno(_("could not open '%s' for reading"),
1487 git_path("MERGE_HEAD"));
1488 while (strbuf_getline(&m
, fp
, '\n') != EOF
) {
1489 struct commit
*parent
;
1491 parent
= get_merge_parent(m
.buf
);
1493 die(_("Corrupt MERGE_HEAD file (%s)"), m
.buf
);
1494 pptr
= &commit_list_insert(parent
, pptr
)->next
;
1498 if (!stat(git_path("MERGE_MODE"), &statbuf
)) {
1499 if (strbuf_read_file(&sb
, git_path("MERGE_MODE"), 0) < 0)
1500 die_errno(_("could not read MERGE_MODE"));
1501 if (!strcmp(sb
.buf
, "no-ff"))
1502 allow_fast_forward
= 0;
1504 if (allow_fast_forward
)
1505 parents
= reduce_heads(parents
);
1508 reflog_msg
= (whence
== FROM_CHERRY_PICK
)
1509 ? "commit (cherry-pick)"
1511 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1514 /* Finally, get the commit message */
1516 if (strbuf_read_file(&sb
, git_path(commit_editmsg
), 0) < 0) {
1517 int saved_errno
= errno
;
1518 rollback_index_files();
1519 die(_("could not read commit message: %s"), strerror(saved_errno
));
1522 /* Truncate the message just before the diff, if any. */
1524 p
= strstr(sb
.buf
, "\ndiff --git ");
1526 strbuf_setlen(&sb
, p
- sb
.buf
+ 1);
1529 if (cleanup_mode
!= CLEANUP_NONE
)
1530 stripspace(&sb
, cleanup_mode
== CLEANUP_ALL
);
1531 if (template_untouched(&sb
) && !allow_empty_message
) {
1532 rollback_index_files();
1533 fprintf(stderr
, _("Aborting commit; you did not edit the message.\n"));
1536 if (message_is_empty(&sb
) && !allow_empty_message
) {
1537 rollback_index_files();
1538 fprintf(stderr
, _("Aborting commit due to empty commit message.\n"));
1543 const char *exclude_gpgsig
[2] = { "gpgsig", NULL
};
1544 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1546 struct commit_extra_header
**tail
= &extra
;
1547 append_merge_tag_headers(parents
, &tail
);
1550 if (commit_tree_extended(&sb
, active_cache_tree
->sha1
, parents
, sha1
,
1551 author_ident
.buf
, sign_commit
, extra
)) {
1552 rollback_index_files();
1553 die(_("failed to write commit object"));
1555 strbuf_release(&author_ident
);
1556 free_commit_extra_headers(extra
);
1558 ref_lock
= lock_any_ref_for_update("HEAD",
1561 : current_head
->object
.sha1
,
1564 nl
= strchr(sb
.buf
, '\n');
1566 strbuf_setlen(&sb
, nl
+ 1 - sb
.buf
);
1568 strbuf_addch(&sb
, '\n');
1569 strbuf_insert(&sb
, 0, reflog_msg
, strlen(reflog_msg
));
1570 strbuf_insert(&sb
, strlen(reflog_msg
), ": ", 2);
1573 rollback_index_files();
1574 die(_("cannot lock HEAD ref"));
1576 if (write_ref_sha1(ref_lock
, sha1
, sb
.buf
) < 0) {
1577 rollback_index_files();
1578 die(_("cannot update HEAD ref"));
1581 unlink(git_path("CHERRY_PICK_HEAD"));
1582 unlink(git_path("REVERT_HEAD"));
1583 unlink(git_path("MERGE_HEAD"));
1584 unlink(git_path("MERGE_MSG"));
1585 unlink(git_path("MERGE_MODE"));
1586 unlink(git_path("SQUASH_MSG"));
1588 if (commit_index_files())
1589 die (_("Repository has been updated, but unable to write\n"
1590 "new_index file. Check that disk is not full or quota is\n"
1591 "not exceeded, and then \"git reset HEAD\" to recover."));
1594 run_hook(get_index_file(), "post-commit", NULL
);
1595 if (amend
&& !no_post_rewrite
) {
1596 struct notes_rewrite_cfg
*cfg
;
1597 cfg
= init_copy_notes_for_rewrite("amend");
1599 /* we are amending, so current_head is not NULL */
1600 copy_note_for_rewrite(cfg
, current_head
->object
.sha1
, sha1
);
1601 finish_copy_notes_for_rewrite(cfg
);
1603 run_rewrite_hook(current_head
->object
.sha1
, sha1
);
1606 print_summary(prefix
, sha1
, !current_head
);