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 #include "sequencer.h"
33 static const char * const builtin_commit_usage
[] = {
34 N_("git commit [options] [--] <pathspec>..."),
38 static const char * const builtin_status_usage
[] = {
39 N_("git status [options] [--] <pathspec>..."),
43 static const char implicit_ident_advice
[] =
44 N_("Your name and email address were configured automatically based\n"
45 "on your username and hostname. Please check that they are accurate.\n"
46 "You can suppress this message by setting them explicitly:\n"
48 " git config --global user.name \"Your Name\"\n"
49 " git config --global user.email you@example.com\n"
51 "After doing this, you may fix the identity used for this commit with:\n"
53 " git commit --amend --reset-author\n");
55 static const char empty_amend_advice
[] =
56 N_("You asked to amend the most recent commit, but doing so would make\n"
57 "it empty. You can repeat your command with --allow-empty, or you can\n"
58 "remove the commit entirely with \"git reset HEAD^\".\n");
60 static const char empty_cherry_pick_advice
[] =
61 N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
62 "If you wish to commit it anyway, use:\n"
64 " git commit --allow-empty\n"
66 "Otherwise, please use 'git reset'\n");
68 static const char *use_message_buffer
;
69 static const char commit_editmsg
[] = "COMMIT_EDITMSG";
70 static struct lock_file index_lock
; /* real index */
71 static struct lock_file false_lock
; /* used only for partial commits */
78 static const char *logfile
, *force_author
;
79 static const char *template_file
;
81 * The _message variables are commit names from which to take
82 * the commit message and/or authorship.
84 static const char *author_message
, *author_message_buffer
;
85 static char *edit_message
, *use_message
;
86 static char *fixup_message
, *squash_message
;
87 static int all
, also
, interactive
, patch_interactive
, only
, amend
, signoff
;
88 static int edit_flag
= -1; /* unspecified */
89 static int quiet
, verbose
, no_verify
, allow_empty
, dry_run
, renew_authorship
;
90 static int no_post_rewrite
, allow_empty_message
;
91 static char *untracked_files_arg
, *force_date
, *ignore_submodule_arg
;
92 static char *sign_commit
;
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 const 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
;
115 STATUS_FORMAT_NONE
= 0,
118 STATUS_FORMAT_PORCELAIN
121 static int opt_parse_m(const struct option
*opt
, const char *arg
, int unset
)
123 struct strbuf
*buf
= opt
->value
;
125 strbuf_setlen(buf
, 0);
128 strbuf_addch(buf
, '\n');
129 strbuf_addstr(buf
, arg
);
130 strbuf_complete_line(buf
);
135 static void determine_whence(struct wt_status
*s
)
137 if (file_exists(git_path("MERGE_HEAD")))
139 else if (file_exists(git_path("CHERRY_PICK_HEAD")))
140 whence
= FROM_CHERRY_PICK
;
142 whence
= FROM_COMMIT
;
147 static void rollback_index_files(void)
149 switch (commit_style
) {
151 break; /* nothing to do */
153 rollback_lock_file(&index_lock
);
156 rollback_lock_file(&index_lock
);
157 rollback_lock_file(&false_lock
);
162 static int commit_index_files(void)
166 switch (commit_style
) {
168 break; /* nothing to do */
170 err
= commit_lock_file(&index_lock
);
173 err
= commit_lock_file(&index_lock
);
174 rollback_lock_file(&false_lock
);
182 * Take a union of paths in the index and the named tree (typically, "HEAD"),
183 * and return the paths that match the given pattern in list.
185 static int list_paths(struct string_list
*list
, const char *with_tree
,
186 const char *prefix
, const char **pattern
)
194 for (i
= 0; pattern
[i
]; i
++)
199 char *max_prefix
= common_prefix(pattern
);
200 overlay_tree_on_cache(with_tree
, max_prefix
? max_prefix
: prefix
);
204 for (i
= 0; i
< active_nr
; i
++) {
205 struct cache_entry
*ce
= active_cache
[i
];
206 struct string_list_item
*item
;
208 if (ce
->ce_flags
& CE_UPDATE
)
210 if (!match_pathspec(pattern
, ce
->name
, ce_namelen(ce
), 0, m
))
212 item
= string_list_insert(list
, ce
->name
);
213 if (ce_skip_worktree(ce
))
214 item
->util
= item
; /* better a valid pointer than a fake one */
217 return report_path_error(m
, pattern
, prefix
);
220 static void add_remove_files(struct string_list
*list
)
223 for (i
= 0; i
< list
->nr
; i
++) {
225 struct string_list_item
*p
= &(list
->items
[i
]);
227 /* p->util is skip-worktree */
231 if (!lstat(p
->string
, &st
)) {
232 if (add_to_cache(p
->string
, &st
, 0))
233 die(_("updating files failed"));
235 remove_file_from_cache(p
->string
);
239 static void create_base_index(const struct commit
*current_head
)
242 struct unpack_trees_options opts
;
250 memset(&opts
, 0, sizeof(opts
));
254 opts
.src_index
= &the_index
;
255 opts
.dst_index
= &the_index
;
257 opts
.fn
= oneway_merge
;
258 tree
= parse_tree_indirect(current_head
->object
.sha1
);
260 die(_("failed to unpack HEAD tree object"));
262 init_tree_desc(&t
, tree
->buffer
, tree
->size
);
263 if (unpack_trees(1, &t
, &opts
))
264 exit(128); /* We've already reported the error, finish dying */
267 static void refresh_cache_or_die(int refresh_flags
)
270 * refresh_flags contains REFRESH_QUIET, so the only errors
271 * are for unmerged entries.
273 if (refresh_cache(refresh_flags
| REFRESH_IN_PORCELAIN
))
274 die_resolve_conflict("commit");
277 static char *prepare_index(int argc
, const char **argv
, const char *prefix
,
278 const struct commit
*current_head
, int is_status
)
281 struct string_list partial
;
282 const char **pathspec
= NULL
;
283 char *old_index_env
= NULL
;
284 int refresh_flags
= REFRESH_QUIET
;
287 refresh_flags
|= REFRESH_UNMERGED
;
290 pathspec
= get_pathspec(prefix
, argv
);
292 if (read_cache_preload(pathspec
) < 0)
293 die(_("index file corrupt"));
296 fd
= hold_locked_index(&index_lock
, 1);
298 refresh_cache_or_die(refresh_flags
);
300 if (write_cache(fd
, active_cache
, active_nr
) ||
301 close_lock_file(&index_lock
))
302 die(_("unable to create temporary index"));
304 old_index_env
= getenv(INDEX_ENVIRONMENT
);
305 setenv(INDEX_ENVIRONMENT
, index_lock
.filename
, 1);
307 if (interactive_add(argc
, argv
, prefix
, patch_interactive
) != 0)
308 die(_("interactive add failed"));
310 if (old_index_env
&& *old_index_env
)
311 setenv(INDEX_ENVIRONMENT
, old_index_env
, 1);
313 unsetenv(INDEX_ENVIRONMENT
);
316 read_cache_from(index_lock
.filename
);
318 commit_style
= COMMIT_NORMAL
;
319 return index_lock
.filename
;
323 * Non partial, non as-is commit.
325 * (1) get the real index;
326 * (2) update the_index as necessary;
327 * (3) write the_index out to the real index (still locked);
328 * (4) return the name of the locked index file.
330 * The caller should run hooks on the locked real index, and
331 * (A) if all goes well, commit the real index;
332 * (B) on failure, rollback the real index.
334 if (all
|| (also
&& pathspec
&& *pathspec
)) {
335 fd
= hold_locked_index(&index_lock
, 1);
336 add_files_to_cache(also
? prefix
: NULL
, pathspec
, 0);
337 refresh_cache_or_die(refresh_flags
);
338 update_main_cache_tree(WRITE_TREE_SILENT
);
339 if (write_cache(fd
, active_cache
, active_nr
) ||
340 close_lock_file(&index_lock
))
341 die(_("unable to write new_index file"));
342 commit_style
= COMMIT_NORMAL
;
343 return index_lock
.filename
;
349 * (1) return the name of the real index file.
351 * The caller should run hooks on the real index,
352 * and create commit from the_index.
353 * We still need to refresh the index here.
355 if (!only
&& (!pathspec
|| !*pathspec
)) {
356 fd
= hold_locked_index(&index_lock
, 1);
357 refresh_cache_or_die(refresh_flags
);
358 if (active_cache_changed
) {
359 update_main_cache_tree(WRITE_TREE_SILENT
);
360 if (write_cache(fd
, active_cache
, active_nr
) ||
361 commit_locked_index(&index_lock
))
362 die(_("unable to write new_index file"));
364 rollback_lock_file(&index_lock
);
366 commit_style
= COMMIT_AS_IS
;
367 return get_index_file();
373 * (0) find the set of affected paths;
374 * (1) get lock on the real index file;
375 * (2) update the_index with the given paths;
376 * (3) write the_index out to the real index (still locked);
377 * (4) get lock on the false index file;
378 * (5) reset the_index from HEAD;
379 * (6) update the_index the same way as (2);
380 * (7) write the_index out to the false index file;
381 * (8) return the name of the false index file (still locked);
383 * The caller should run hooks on the locked false index, and
384 * create commit from it. Then
385 * (A) if all goes well, commit the real index;
386 * (B) on failure, rollback the real index;
387 * In either case, rollback the false index.
389 commit_style
= COMMIT_PARTIAL
;
391 if (whence
!= FROM_COMMIT
) {
392 if (whence
== FROM_MERGE
)
393 die(_("cannot do a partial commit during a merge."));
394 else if (whence
== FROM_CHERRY_PICK
)
395 die(_("cannot do a partial commit during a cherry-pick."));
398 memset(&partial
, 0, sizeof(partial
));
399 partial
.strdup_strings
= 1;
400 if (list_paths(&partial
, !current_head
? NULL
: "HEAD", prefix
, pathspec
))
404 if (read_cache() < 0)
405 die(_("cannot read the index"));
407 fd
= hold_locked_index(&index_lock
, 1);
408 add_remove_files(&partial
);
409 refresh_cache(REFRESH_QUIET
);
410 if (write_cache(fd
, active_cache
, active_nr
) ||
411 close_lock_file(&index_lock
))
412 die(_("unable to write new_index file"));
414 fd
= hold_lock_file_for_update(&false_lock
,
415 git_path("next-index-%"PRIuMAX
,
416 (uintmax_t) getpid()),
419 create_base_index(current_head
);
420 add_remove_files(&partial
);
421 refresh_cache(REFRESH_QUIET
);
423 if (write_cache(fd
, active_cache
, active_nr
) ||
424 close_lock_file(&false_lock
))
425 die(_("unable to write temporary index file"));
428 read_cache_from(false_lock
.filename
);
430 return false_lock
.filename
;
433 static int run_status(FILE *fp
, const char *index_file
, const char *prefix
, int nowarn
,
436 unsigned char sha1
[20];
438 if (s
->relative_paths
)
443 s
->reference
= "HEAD^1";
445 s
->verbose
= verbose
;
446 s
->index_file
= index_file
;
449 s
->is_initial
= get_sha1(s
->reference
, sha1
) ? 1 : 0;
451 wt_status_collect(s
);
453 switch (status_format
) {
454 case STATUS_FORMAT_SHORT
:
455 wt_shortstatus_print(s
);
457 case STATUS_FORMAT_PORCELAIN
:
458 wt_porcelain_print(s
);
460 case STATUS_FORMAT_NONE
:
461 case STATUS_FORMAT_LONG
:
466 return s
->commitable
;
469 static int is_a_merge(const struct commit
*current_head
)
471 return !!(current_head
->parents
&& current_head
->parents
->next
);
474 static void export_one(const char *var
, const char *s
, const char *e
, int hack
)
476 struct strbuf buf
= STRBUF_INIT
;
478 strbuf_addch(&buf
, hack
);
479 strbuf_addf(&buf
, "%.*s", (int)(e
- s
), s
);
480 setenv(var
, buf
.buf
, 1);
481 strbuf_release(&buf
);
484 static int sane_ident_split(struct ident_split
*person
)
486 if (!person
->name_begin
|| !person
->name_end
||
487 person
->name_begin
== person
->name_end
)
488 return 0; /* no human readable name */
489 if (!person
->mail_begin
|| !person
->mail_end
||
490 person
->mail_begin
== person
->mail_end
)
491 return 0; /* no usable mail */
492 if (!person
->date_begin
|| !person
->date_end
||
493 !person
->tz_begin
|| !person
->tz_end
)
498 static void determine_author_info(struct strbuf
*author_ident
)
500 char *name
, *email
, *date
;
501 struct ident_split author
;
503 name
= getenv("GIT_AUTHOR_NAME");
504 email
= getenv("GIT_AUTHOR_EMAIL");
505 date
= getenv("GIT_AUTHOR_DATE");
507 if (author_message
) {
508 const char *a
, *lb
, *rb
, *eol
;
511 a
= strstr(author_message_buffer
, "\nauthor ");
513 die(_("invalid commit: %s"), author_message
);
515 lb
= strchrnul(a
+ strlen("\nauthor "), '<');
516 rb
= strchrnul(lb
, '>');
517 eol
= strchrnul(rb
, '\n');
518 if (!*lb
|| !*rb
|| !*eol
)
519 die(_("invalid commit: %s"), author_message
);
521 if (lb
== a
+ strlen("\nauthor "))
522 /* \nauthor <foo@example.com> */
523 name
= xcalloc(1, 1);
525 name
= xmemdupz(a
+ strlen("\nauthor "),
527 (a
+ strlen("\nauthor "))));
528 email
= xmemdupz(lb
+ strlen("<"), rb
- (lb
+ strlen("<")));
529 date
= xmemdupz(rb
+ strlen("> "), eol
- (rb
+ strlen("> ")));
530 len
= eol
- (rb
+ strlen("> "));
531 date
= xmalloc(len
+ 2);
533 memcpy(date
+ 1, rb
+ strlen("> "), len
);
534 date
[len
+ 1] = '\0';
538 const char *lb
= strstr(force_author
, " <");
539 const char *rb
= strchr(force_author
, '>');
542 die(_("malformed --author parameter"));
543 name
= xstrndup(force_author
, lb
- force_author
);
544 email
= xstrndup(lb
+ 2, rb
- (lb
+ 2));
549 strbuf_addstr(author_ident
, fmt_ident(name
, email
, date
, IDENT_STRICT
));
550 if (!split_ident_line(&author
, author_ident
->buf
, author_ident
->len
) &&
551 sane_ident_split(&author
)) {
552 export_one("GIT_AUTHOR_NAME", author
.name_begin
, author
.name_end
, 0);
553 export_one("GIT_AUTHOR_EMAIL", author
.mail_begin
, author
.mail_end
, 0);
554 export_one("GIT_AUTHOR_DATE", author
.date_begin
, author
.tz_end
, '@');
558 static char *cut_ident_timestamp_part(char *string
)
560 char *ket
= strrchr(string
, '>');
561 if (!ket
|| ket
[1] != ' ')
562 die(_("Malformed ident string: '%s'"), string
);
567 static int prepare_to_commit(const char *index_file
, const char *prefix
,
568 struct commit
*current_head
,
570 struct strbuf
*author_ident
)
573 struct strbuf committer_ident
= STRBUF_INIT
;
574 int commitable
, saved_color_setting
;
575 struct strbuf sb
= STRBUF_INIT
;
577 const char *hook_arg1
= NULL
;
578 const char *hook_arg2
= NULL
;
580 int clean_message_contents
= (cleanup_mode
!= CLEANUP_NONE
);
582 /* This checks and barfs if author is badly specified */
583 determine_author_info(author_ident
);
585 if (!no_verify
&& run_hook(index_file
, "pre-commit", NULL
))
588 if (squash_message
) {
590 * Insert the proper subject line before other commit
591 * message options add their content.
593 if (use_message
&& !strcmp(use_message
, squash_message
))
594 strbuf_addstr(&sb
, "squash! ");
596 struct pretty_print_context ctx
= {0};
598 c
= lookup_commit_reference_by_name(squash_message
);
600 die(_("could not lookup commit %s"), squash_message
);
601 ctx
.output_encoding
= get_commit_output_encoding();
602 format_commit_message(c
, "squash! %s\n\n", &sb
,
608 strbuf_addbuf(&sb
, &message
);
609 hook_arg1
= "message";
610 } else if (logfile
&& !strcmp(logfile
, "-")) {
612 fprintf(stderr
, _("(reading log message from standard input)\n"));
613 if (strbuf_read(&sb
, 0, 0) < 0)
614 die_errno(_("could not read log from standard input"));
615 hook_arg1
= "message";
616 } else if (logfile
) {
617 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
618 die_errno(_("could not read log file '%s'"),
620 hook_arg1
= "message";
621 } else if (use_message
) {
622 buffer
= strstr(use_message_buffer
, "\n\n");
623 if (!use_editor
&& (!buffer
|| buffer
[2] == '\0'))
624 die(_("commit has empty message"));
625 strbuf_add(&sb
, buffer
+ 2, strlen(buffer
+ 2));
626 hook_arg1
= "commit";
627 hook_arg2
= use_message
;
628 } else if (fixup_message
) {
629 struct pretty_print_context ctx
= {0};
630 struct commit
*commit
;
631 commit
= lookup_commit_reference_by_name(fixup_message
);
633 die(_("could not lookup commit %s"), fixup_message
);
634 ctx
.output_encoding
= get_commit_output_encoding();
635 format_commit_message(commit
, "fixup! %s\n\n",
637 hook_arg1
= "message";
638 } else if (!stat(git_path("MERGE_MSG"), &statbuf
)) {
639 if (strbuf_read_file(&sb
, git_path("MERGE_MSG"), 0) < 0)
640 die_errno(_("could not read MERGE_MSG"));
642 } else if (!stat(git_path("SQUASH_MSG"), &statbuf
)) {
643 if (strbuf_read_file(&sb
, git_path("SQUASH_MSG"), 0) < 0)
644 die_errno(_("could not read SQUASH_MSG"));
645 hook_arg1
= "squash";
646 } else if (template_file
) {
647 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
648 die_errno(_("could not read '%s'"), template_file
);
649 hook_arg1
= "template";
650 clean_message_contents
= 0;
654 * The remaining cases don't modify the template message, but
655 * just set the argument(s) to the prepare-commit-msg hook.
657 else if (whence
== FROM_MERGE
)
659 else if (whence
== FROM_CHERRY_PICK
) {
660 hook_arg1
= "commit";
661 hook_arg2
= "CHERRY_PICK_HEAD";
664 if (squash_message
) {
666 * If squash_commit was used for the commit subject,
667 * then we're possibly hijacking other commit log options.
668 * Reset the hook args to tell the real story.
670 hook_arg1
= "message";
674 s
->fp
= fopen(git_path(commit_editmsg
), "w");
676 die_errno(_("could not open '%s'"), git_path(commit_editmsg
));
678 if (clean_message_contents
)
683 * See if we have a Conflicts: block at the end. If yes, count
684 * its size, so we can ignore it.
686 int ignore_footer
= 0;
687 int i
, eol
, previous
= 0;
690 for (i
= 0; i
< sb
.len
; i
++) {
691 nl
= memchr(sb
.buf
+ i
, '\n', sb
.len
- i
);
696 if (!prefixcmp(sb
.buf
+ previous
, "\nConflicts:\n")) {
697 ignore_footer
= sb
.len
- previous
;
705 append_signoff(&sb
, ignore_footer
, 0);
708 if (fwrite(sb
.buf
, 1, sb
.len
, s
->fp
) < sb
.len
)
709 die_errno(_("could not write commit template"));
713 /* This checks if committer ident is explicitly given */
714 strbuf_addstr(&committer_ident
, git_committer_info(IDENT_STRICT
));
715 if (use_editor
&& include_status
) {
716 char *ai_tmp
, *ci_tmp
;
717 if (whence
!= FROM_COMMIT
)
718 status_printf_ln(s
, GIT_COLOR_NORMAL
,
721 "It looks like you may be committing a merge.\n"
722 "If this is not correct, please remove the file\n"
726 "It looks like you may be committing a cherry-pick.\n"
727 "If this is not correct, please remove the file\n"
730 git_path(whence
== FROM_MERGE
732 : "CHERRY_PICK_HEAD"));
734 fprintf(s
->fp
, "\n");
735 if (cleanup_mode
== CLEANUP_ALL
)
736 status_printf(s
, GIT_COLOR_NORMAL
,
737 _("Please enter the commit message for your changes."
738 " Lines starting\nwith '%c' will be ignored, and an empty"
739 " message aborts the commit.\n"), comment_line_char
);
740 else /* CLEANUP_SPACE, that is. */
741 status_printf(s
, GIT_COLOR_NORMAL
,
742 _("Please enter the commit message for your changes."
744 "with '%c' will be kept; you may remove them"
745 " yourself if you want to.\n"
746 "An empty message aborts the commit.\n"), comment_line_char
);
747 if (only_include_assumed
)
748 status_printf_ln(s
, GIT_COLOR_NORMAL
,
749 "%s", only_include_assumed
);
751 ai_tmp
= cut_ident_timestamp_part(author_ident
->buf
);
752 ci_tmp
= cut_ident_timestamp_part(committer_ident
.buf
);
753 if (strcmp(author_ident
->buf
, committer_ident
.buf
))
754 status_printf_ln(s
, GIT_COLOR_NORMAL
,
757 ident_shown
++ ? "" : "\n",
760 if (!committer_ident_sufficiently_given())
761 status_printf_ln(s
, GIT_COLOR_NORMAL
,
764 ident_shown
++ ? "" : "\n",
765 committer_ident
.buf
);
768 status_printf_ln(s
, GIT_COLOR_NORMAL
, "");
770 saved_color_setting
= s
->use_color
;
772 commitable
= run_status(s
->fp
, index_file
, prefix
, 1, s
);
773 s
->use_color
= saved_color_setting
;
778 unsigned char sha1
[20];
779 const char *parent
= "HEAD";
781 if (!active_nr
&& read_cache() < 0)
782 die(_("Cannot read index"));
787 if (get_sha1(parent
, sha1
))
788 commitable
= !!active_nr
;
790 commitable
= index_differs_from(parent
, 0);
792 strbuf_release(&committer_ident
);
797 * Reject an attempt to record a non-merge empty commit without
798 * explicit --allow-empty. In the cherry-pick case, it may be
799 * empty due to conflict resolution, which the user should okay.
801 if (!commitable
&& whence
!= FROM_MERGE
&& !allow_empty
&&
802 !(amend
&& is_a_merge(current_head
))) {
803 run_status(stdout
, index_file
, prefix
, 0, s
);
805 fputs(_(empty_amend_advice
), stderr
);
806 else if (whence
== FROM_CHERRY_PICK
)
807 fputs(_(empty_cherry_pick_advice
), stderr
);
812 * Re-read the index as pre-commit hook could have updated it,
813 * and write it out as a tree. We must do this before we invoke
814 * the editor and after we invoke run_status above.
817 read_cache_from(index_file
);
818 if (update_main_cache_tree(0)) {
819 error(_("Error building trees"));
823 if (run_hook(index_file
, "prepare-commit-msg",
824 git_path(commit_editmsg
), hook_arg1
, hook_arg2
, NULL
))
828 char index
[PATH_MAX
];
829 const char *env
[2] = { NULL
};
831 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
832 if (launch_editor(git_path(commit_editmsg
), NULL
, env
)) {
834 _("Please supply the message using either -m or -F option.\n"));
840 run_hook(index_file
, "commit-msg", git_path(commit_editmsg
), NULL
)) {
847 static int rest_is_empty(struct strbuf
*sb
, int start
)
852 /* Check if the rest is just whitespace and Signed-of-by's. */
853 for (i
= start
; i
< sb
->len
; i
++) {
854 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
860 if (strlen(sign_off_header
) <= eol
- i
&&
861 !prefixcmp(sb
->buf
+ i
, sign_off_header
)) {
866 if (!isspace(sb
->buf
[i
++]))
874 * Find out if the message in the strbuf contains only whitespace and
875 * Signed-off-by lines.
877 static int message_is_empty(struct strbuf
*sb
)
879 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
881 return rest_is_empty(sb
, 0);
885 * See if the user edited the message in the editor or left what
886 * was in the template intact
888 static int template_untouched(struct strbuf
*sb
)
890 struct strbuf tmpl
= STRBUF_INIT
;
893 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
896 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
899 stripspace(&tmpl
, cleanup_mode
== CLEANUP_ALL
);
900 start
= (char *)skip_prefix(sb
->buf
, tmpl
.buf
);
903 strbuf_release(&tmpl
);
904 return rest_is_empty(sb
, start
- sb
->buf
);
907 static const char *find_author_by_nickname(const char *name
)
909 struct rev_info revs
;
910 struct commit
*commit
;
911 struct strbuf buf
= STRBUF_INIT
;
915 init_revisions(&revs
, NULL
);
916 strbuf_addf(&buf
, "--author=%s", name
);
921 setup_revisions(ac
, av
, &revs
, NULL
);
922 prepare_revision_walk(&revs
);
923 commit
= get_revision(&revs
);
925 struct pretty_print_context ctx
= {0};
926 ctx
.date_mode
= DATE_NORMAL
;
927 strbuf_release(&buf
);
928 format_commit_message(commit
, "%an <%ae>", &buf
, &ctx
);
929 return strbuf_detach(&buf
, NULL
);
931 die(_("No existing author found with '%s'"), name
);
935 static void handle_untracked_files_arg(struct wt_status
*s
)
937 if (!untracked_files_arg
)
938 ; /* default already initialized */
939 else if (!strcmp(untracked_files_arg
, "no"))
940 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
941 else if (!strcmp(untracked_files_arg
, "normal"))
942 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
943 else if (!strcmp(untracked_files_arg
, "all"))
944 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
946 die(_("Invalid untracked files mode '%s'"), untracked_files_arg
);
949 static const char *read_commit_message(const char *name
)
952 struct commit
*commit
;
954 commit
= lookup_commit_reference_by_name(name
);
956 die(_("could not lookup commit %s"), name
);
957 out_enc
= get_commit_output_encoding();
958 return logmsg_reencode(commit
, NULL
, out_enc
);
961 static int parse_and_validate_options(int argc
, const char *argv
[],
962 const struct option
*options
,
963 const char * const usage
[],
965 struct commit
*current_head
,
970 argc
= parse_options(argc
, argv
, prefix
, options
, usage
, 0);
972 if (force_author
&& !strchr(force_author
, '>'))
973 force_author
= find_author_by_nickname(force_author
);
975 if (force_author
&& renew_authorship
)
976 die(_("Using both --reset-author and --author does not make sense"));
978 if (logfile
|| message
.len
|| use_message
|| fixup_message
)
981 use_editor
= edit_flag
;
983 setenv("GIT_EDITOR", ":", 1);
985 /* Sanity check options */
986 if (amend
&& !current_head
)
987 die(_("You have nothing to amend."));
988 if (amend
&& whence
!= FROM_COMMIT
) {
989 if (whence
== FROM_MERGE
)
990 die(_("You are in the middle of a merge -- cannot amend."));
991 else if (whence
== FROM_CHERRY_PICK
)
992 die(_("You are in the middle of a cherry-pick -- cannot amend."));
994 if (fixup_message
&& squash_message
)
995 die(_("Options --squash and --fixup cannot be used together"));
1005 die(_("Only one of -c/-C/-F/--fixup can be used."));
1006 if (message
.len
&& f
> 0)
1007 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1008 if (f
|| message
.len
)
1009 template_file
= NULL
;
1011 use_message
= edit_message
;
1012 if (amend
&& !use_message
&& !fixup_message
)
1013 use_message
= "HEAD";
1014 if (!use_message
&& whence
!= FROM_CHERRY_PICK
&& renew_authorship
)
1015 die(_("--reset-author can be used only with -C, -c or --amend."));
1017 use_message_buffer
= read_commit_message(use_message
);
1018 if (!renew_authorship
) {
1019 author_message
= use_message
;
1020 author_message_buffer
= use_message_buffer
;
1023 if (whence
== FROM_CHERRY_PICK
&& !renew_authorship
) {
1024 author_message
= "CHERRY_PICK_HEAD";
1025 author_message_buffer
= read_commit_message(author_message
);
1028 if (patch_interactive
)
1031 if (!!also
+ !!only
+ !!all
+ !!interactive
> 1)
1032 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1033 if (argc
== 0 && (also
|| (only
&& !amend
)))
1034 die(_("No paths with --include/--only does not make sense."));
1035 if (argc
== 0 && only
&& amend
)
1036 only_include_assumed
= _("Clever... amending the last one with dirty index.");
1037 if (argc
> 0 && !also
&& !only
)
1038 only_include_assumed
= _("Explicit paths specified without -i nor -o; assuming --only paths...");
1039 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
1040 cleanup_mode
= use_editor
? CLEANUP_ALL
: CLEANUP_SPACE
;
1041 else if (!strcmp(cleanup_arg
, "verbatim"))
1042 cleanup_mode
= CLEANUP_NONE
;
1043 else if (!strcmp(cleanup_arg
, "whitespace"))
1044 cleanup_mode
= CLEANUP_SPACE
;
1045 else if (!strcmp(cleanup_arg
, "strip"))
1046 cleanup_mode
= CLEANUP_ALL
;
1048 die(_("Invalid cleanup mode %s"), cleanup_arg
);
1050 handle_untracked_files_arg(s
);
1052 if (all
&& argc
> 0)
1053 die(_("Paths with -a does not make sense."));
1055 if (s
->null_termination
) {
1056 if (status_format
== STATUS_FORMAT_NONE
)
1057 status_format
= STATUS_FORMAT_PORCELAIN
;
1058 else if (status_format
== STATUS_FORMAT_LONG
)
1059 die(_("--long and -z are incompatible"));
1061 if (status_format
!= STATUS_FORMAT_NONE
)
1067 static int dry_run_commit(int argc
, const char **argv
, const char *prefix
,
1068 const struct commit
*current_head
, struct wt_status
*s
)
1071 const char *index_file
;
1073 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 1);
1074 commitable
= run_status(stdout
, index_file
, prefix
, 0, s
);
1075 rollback_index_files();
1077 return commitable
? 0 : 1;
1080 static int parse_status_slot(const char *var
, int offset
)
1082 if (!strcasecmp(var
+offset
, "header"))
1083 return WT_STATUS_HEADER
;
1084 if (!strcasecmp(var
+offset
, "branch"))
1085 return WT_STATUS_ONBRANCH
;
1086 if (!strcasecmp(var
+offset
, "updated")
1087 || !strcasecmp(var
+offset
, "added"))
1088 return WT_STATUS_UPDATED
;
1089 if (!strcasecmp(var
+offset
, "changed"))
1090 return WT_STATUS_CHANGED
;
1091 if (!strcasecmp(var
+offset
, "untracked"))
1092 return WT_STATUS_UNTRACKED
;
1093 if (!strcasecmp(var
+offset
, "nobranch"))
1094 return WT_STATUS_NOBRANCH
;
1095 if (!strcasecmp(var
+offset
, "unmerged"))
1096 return WT_STATUS_UNMERGED
;
1100 static int git_status_config(const char *k
, const char *v
, void *cb
)
1102 struct wt_status
*s
= cb
;
1104 if (!prefixcmp(k
, "column."))
1105 return git_column_config(k
, v
, "status", &s
->colopts
);
1106 if (!strcmp(k
, "status.submodulesummary")) {
1108 s
->submodule_summary
= git_config_bool_or_int(k
, v
, &is_bool
);
1109 if (is_bool
&& s
->submodule_summary
)
1110 s
->submodule_summary
= -1;
1113 if (!strcmp(k
, "status.short")) {
1114 if (git_config_bool(k
, v
))
1115 status_format
= STATUS_FORMAT_SHORT
;
1117 status_format
= STATUS_FORMAT_NONE
;
1120 if (!strcmp(k
, "status.branch")) {
1121 s
->show_branch
= git_config_bool(k
, v
);
1124 if (!strcmp(k
, "status.color") || !strcmp(k
, "color.status")) {
1125 s
->use_color
= git_config_colorbool(k
, v
);
1128 if (!prefixcmp(k
, "status.color.") || !prefixcmp(k
, "color.status.")) {
1129 int slot
= parse_status_slot(k
, 13);
1133 return config_error_nonbool(k
);
1134 color_parse(v
, k
, s
->color_palette
[slot
]);
1137 if (!strcmp(k
, "status.relativepaths")) {
1138 s
->relative_paths
= git_config_bool(k
, v
);
1141 if (!strcmp(k
, "status.showuntrackedfiles")) {
1143 return config_error_nonbool(k
);
1144 else if (!strcmp(v
, "no"))
1145 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1146 else if (!strcmp(v
, "normal"))
1147 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1148 else if (!strcmp(v
, "all"))
1149 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1151 return error(_("Invalid untracked files mode '%s'"), v
);
1154 return git_diff_ui_config(k
, v
, NULL
);
1157 int cmd_status(int argc
, const char **argv
, const char *prefix
)
1159 static struct wt_status s
;
1161 unsigned char sha1
[20];
1162 static struct option builtin_status_options
[] = {
1163 OPT__VERBOSE(&verbose
, N_("be verbose")),
1164 OPT_SET_INT('s', "short", &status_format
,
1165 N_("show status concisely"), STATUS_FORMAT_SHORT
),
1166 OPT_BOOLEAN('b', "branch", &s
.show_branch
,
1167 N_("show branch information")),
1168 OPT_SET_INT(0, "porcelain", &status_format
,
1169 N_("machine-readable output"),
1170 STATUS_FORMAT_PORCELAIN
),
1171 OPT_SET_INT(0, "long", &status_format
,
1172 N_("show status in long format (default)"),
1173 STATUS_FORMAT_LONG
),
1174 OPT_BOOLEAN('z', "null", &s
.null_termination
,
1175 N_("terminate entries with NUL")),
1176 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
,
1178 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1179 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1180 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status
,
1181 N_("show ignored files")),
1182 { OPTION_STRING
, 0, "ignore-submodules", &ignore_submodule_arg
, N_("when"),
1183 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1184 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1185 OPT_COLUMN(0, "column", &s
.colopts
, N_("list untracked files in columns")),
1189 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1190 usage_with_options(builtin_status_usage
, builtin_status_options
);
1192 wt_status_prepare(&s
);
1193 gitmodules_config();
1194 git_config(git_status_config
, &s
);
1195 determine_whence(&s
);
1196 argc
= parse_options(argc
, argv
, prefix
,
1197 builtin_status_options
,
1198 builtin_status_usage
, 0);
1199 finalize_colopts(&s
.colopts
, -1);
1201 if (s
.null_termination
) {
1202 if (status_format
== STATUS_FORMAT_NONE
)
1203 status_format
= STATUS_FORMAT_PORCELAIN
;
1204 else if (status_format
== STATUS_FORMAT_LONG
)
1205 die(_("--long and -z are incompatible"));
1208 handle_untracked_files_arg(&s
);
1209 if (show_ignored_in_status
)
1210 s
.show_ignored_files
= 1;
1212 s
.pathspec
= get_pathspec(prefix
, argv
);
1214 read_cache_preload(s
.pathspec
);
1215 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, s
.pathspec
, NULL
, NULL
);
1217 fd
= hold_locked_index(&index_lock
, 0);
1219 update_index_if_able(&the_index
, &index_lock
);
1221 s
.is_initial
= get_sha1(s
.reference
, sha1
) ? 1 : 0;
1222 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1223 wt_status_collect(&s
);
1225 if (s
.relative_paths
)
1228 switch (status_format
) {
1229 case STATUS_FORMAT_SHORT
:
1230 wt_shortstatus_print(&s
);
1232 case STATUS_FORMAT_PORCELAIN
:
1233 wt_porcelain_print(&s
);
1235 case STATUS_FORMAT_NONE
:
1236 case STATUS_FORMAT_LONG
:
1237 s
.verbose
= verbose
;
1238 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1239 wt_status_print(&s
);
1245 static void print_summary(const char *prefix
, const unsigned char *sha1
,
1248 struct rev_info rev
;
1249 struct commit
*commit
;
1250 struct strbuf format
= STRBUF_INIT
;
1251 unsigned char junk_sha1
[20];
1253 struct pretty_print_context pctx
= {0};
1254 struct strbuf author_ident
= STRBUF_INIT
;
1255 struct strbuf committer_ident
= STRBUF_INIT
;
1257 commit
= lookup_commit(sha1
);
1259 die(_("couldn't look up newly created commit"));
1260 if (!commit
|| parse_commit(commit
))
1261 die(_("could not parse newly created commit"));
1263 strbuf_addstr(&format
, "format:%h] %s");
1265 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1266 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1267 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1268 strbuf_addstr(&format
, "\n Author: ");
1269 strbuf_addbuf_percentquote(&format
, &author_ident
);
1271 if (!committer_ident_sufficiently_given()) {
1272 strbuf_addstr(&format
, "\n Committer: ");
1273 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1274 if (advice_implicit_identity
) {
1275 strbuf_addch(&format
, '\n');
1276 strbuf_addstr(&format
, _(implicit_ident_advice
));
1279 strbuf_release(&author_ident
);
1280 strbuf_release(&committer_ident
);
1282 init_revisions(&rev
, prefix
);
1283 setup_revisions(0, NULL
, &rev
, NULL
);
1286 rev
.diffopt
.output_format
=
1287 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1289 rev
.verbose_header
= 1;
1290 rev
.show_root_diff
= 1;
1291 get_commit_format(format
.buf
, &rev
);
1292 rev
.always_show_header
= 0;
1293 rev
.diffopt
.detect_rename
= 1;
1294 rev
.diffopt
.break_opt
= 0;
1295 diff_setup_done(&rev
.diffopt
);
1297 head
= resolve_ref_unsafe("HEAD", junk_sha1
, 0, NULL
);
1299 !prefixcmp(head
, "refs/heads/") ?
1301 !strcmp(head
, "HEAD") ?
1302 _("detached HEAD") :
1304 initial_commit
? _(" (root-commit)") : "");
1306 if (!log_tree_commit(&rev
, commit
)) {
1307 rev
.always_show_header
= 1;
1308 rev
.use_terminator
= 1;
1309 log_tree_commit(&rev
, commit
);
1312 strbuf_release(&format
);
1315 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1317 struct wt_status
*s
= cb
;
1320 if (!strcmp(k
, "commit.template"))
1321 return git_config_pathname(&template_file
, k
, v
);
1322 if (!strcmp(k
, "commit.status")) {
1323 include_status
= git_config_bool(k
, v
);
1326 if (!strcmp(k
, "commit.cleanup"))
1327 return git_config_string(&cleanup_arg
, k
, v
);
1329 status
= git_gpg_config(k
, v
, NULL
);
1332 return git_status_config(k
, v
, s
);
1335 static int run_rewrite_hook(const unsigned char *oldsha1
,
1336 const unsigned char *newsha1
)
1338 /* oldsha1 SP newsha1 LF NUL */
1339 static char buf
[2*40 + 3];
1340 struct child_process proc
;
1341 const char *argv
[3];
1345 argv
[0] = find_hook("post-rewrite");
1352 memset(&proc
, 0, sizeof(proc
));
1355 proc
.stdout_to_stderr
= 1;
1357 code
= start_command(&proc
);
1360 n
= snprintf(buf
, sizeof(buf
), "%s %s\n",
1361 sha1_to_hex(oldsha1
), sha1_to_hex(newsha1
));
1362 write_in_full(proc
.in
, buf
, n
);
1364 return finish_command(&proc
);
1367 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1369 static struct wt_status s
;
1370 static struct option builtin_commit_options
[] = {
1371 OPT__QUIET(&quiet
, N_("suppress summary after successful commit")),
1372 OPT__VERBOSE(&verbose
, N_("show diff in commit message template")),
1374 OPT_GROUP(N_("Commit message options")),
1375 OPT_FILENAME('F', "file", &logfile
, N_("read message from file")),
1376 OPT_STRING(0, "author", &force_author
, N_("author"), N_("override author for commit")),
1377 OPT_STRING(0, "date", &force_date
, N_("date"), N_("override date for commit")),
1378 OPT_CALLBACK('m', "message", &message
, N_("message"), N_("commit message"), opt_parse_m
),
1379 OPT_STRING('c', "reedit-message", &edit_message
, N_("commit"), N_("reuse and edit message from specified commit")),
1380 OPT_STRING('C', "reuse-message", &use_message
, N_("commit"), N_("reuse message from specified commit")),
1381 OPT_STRING(0, "fixup", &fixup_message
, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1382 OPT_STRING(0, "squash", &squash_message
, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1383 OPT_BOOLEAN(0, "reset-author", &renew_authorship
, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1384 OPT_BOOLEAN('s', "signoff", &signoff
, N_("add Signed-off-by:")),
1385 OPT_FILENAME('t', "template", &template_file
, N_("use specified template file")),
1386 OPT_BOOL('e', "edit", &edit_flag
, N_("force edit of commit")),
1387 OPT_STRING(0, "cleanup", &cleanup_arg
, N_("default"), N_("how to strip spaces and #comments from message")),
1388 OPT_BOOLEAN(0, "status", &include_status
, N_("include status in commit message template")),
1389 { OPTION_STRING
, 'S', "gpg-sign", &sign_commit
, N_("key id"),
1390 N_("GPG sign commit"), PARSE_OPT_OPTARG
, NULL
, (intptr_t) "" },
1391 /* end commit message options */
1393 OPT_GROUP(N_("Commit contents options")),
1394 OPT_BOOLEAN('a', "all", &all
, N_("commit all changed files")),
1395 OPT_BOOLEAN('i', "include", &also
, N_("add specified files to index for commit")),
1396 OPT_BOOLEAN(0, "interactive", &interactive
, N_("interactively add files")),
1397 OPT_BOOLEAN('p', "patch", &patch_interactive
, N_("interactively add changes")),
1398 OPT_BOOLEAN('o', "only", &only
, N_("commit only specified files")),
1399 OPT_BOOLEAN('n', "no-verify", &no_verify
, N_("bypass pre-commit hook")),
1400 OPT_BOOLEAN(0, "dry-run", &dry_run
, N_("show what would be committed")),
1401 OPT_SET_INT(0, "short", &status_format
, N_("show status concisely"),
1402 STATUS_FORMAT_SHORT
),
1403 OPT_BOOLEAN(0, "branch", &s
.show_branch
, N_("show branch information")),
1404 OPT_SET_INT(0, "porcelain", &status_format
,
1405 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN
),
1406 OPT_SET_INT(0, "long", &status_format
,
1407 N_("show status in long format (default)"),
1408 STATUS_FORMAT_LONG
),
1409 OPT_BOOLEAN('z', "null", &s
.null_termination
,
1410 N_("terminate entries with NUL")),
1411 OPT_BOOLEAN(0, "amend", &amend
, N_("amend previous commit")),
1412 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite
, N_("bypass post-rewrite hook")),
1413 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
, N_("mode"), N_("show untracked files, optional modes: all, normal, no. (Default: all)"), PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1414 /* end commit contents options */
1416 { OPTION_BOOLEAN
, 0, "allow-empty", &allow_empty
, NULL
,
1417 N_("ok to record an empty change"),
1418 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
1419 { OPTION_BOOLEAN
, 0, "allow-empty-message", &allow_empty_message
, NULL
,
1420 N_("ok to record a change with an empty message"),
1421 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
1426 struct strbuf sb
= STRBUF_INIT
;
1427 struct strbuf author_ident
= STRBUF_INIT
;
1428 const char *index_file
, *reflog_msg
;
1430 unsigned char sha1
[20];
1431 struct ref_lock
*ref_lock
;
1432 struct commit_list
*parents
= NULL
, **pptr
= &parents
;
1433 struct stat statbuf
;
1434 int allow_fast_forward
= 1;
1435 struct commit
*current_head
= NULL
;
1436 struct commit_extra_header
*extra
= NULL
;
1438 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1439 usage_with_options(builtin_commit_usage
, builtin_commit_options
);
1441 wt_status_prepare(&s
);
1442 gitmodules_config();
1443 git_config(git_commit_config
, &s
);
1444 determine_whence(&s
);
1447 if (get_sha1("HEAD", sha1
))
1448 current_head
= NULL
;
1450 current_head
= lookup_commit_or_die(sha1
, "HEAD");
1451 if (!current_head
|| parse_commit(current_head
))
1452 die(_("could not parse HEAD commit"));
1454 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_options
,
1455 builtin_commit_usage
,
1456 prefix
, current_head
, &s
);
1458 return dry_run_commit(argc
, argv
, prefix
, current_head
, &s
);
1459 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 0);
1461 /* Set up everything for writing the commit object. This includes
1462 running hooks, writing the trees, and interacting with the user. */
1463 if (!prepare_to_commit(index_file
, prefix
,
1464 current_head
, &s
, &author_ident
)) {
1465 rollback_index_files();
1469 /* Determine parents */
1470 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1471 if (!current_head
) {
1473 reflog_msg
= "commit (initial)";
1475 struct commit_list
*c
;
1478 reflog_msg
= "commit (amend)";
1479 for (c
= current_head
->parents
; c
; c
= c
->next
)
1480 pptr
= &commit_list_insert(c
->item
, pptr
)->next
;
1481 } else if (whence
== FROM_MERGE
) {
1482 struct strbuf m
= STRBUF_INIT
;
1486 reflog_msg
= "commit (merge)";
1487 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1488 fp
= fopen(git_path("MERGE_HEAD"), "r");
1490 die_errno(_("could not open '%s' for reading"),
1491 git_path("MERGE_HEAD"));
1492 while (strbuf_getline(&m
, fp
, '\n') != EOF
) {
1493 struct commit
*parent
;
1495 parent
= get_merge_parent(m
.buf
);
1497 die(_("Corrupt MERGE_HEAD file (%s)"), m
.buf
);
1498 pptr
= &commit_list_insert(parent
, pptr
)->next
;
1502 if (!stat(git_path("MERGE_MODE"), &statbuf
)) {
1503 if (strbuf_read_file(&sb
, git_path("MERGE_MODE"), 0) < 0)
1504 die_errno(_("could not read MERGE_MODE"));
1505 if (!strcmp(sb
.buf
, "no-ff"))
1506 allow_fast_forward
= 0;
1508 if (allow_fast_forward
)
1509 parents
= reduce_heads(parents
);
1512 reflog_msg
= (whence
== FROM_CHERRY_PICK
)
1513 ? "commit (cherry-pick)"
1515 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1518 /* Finally, get the commit message */
1520 if (strbuf_read_file(&sb
, git_path(commit_editmsg
), 0) < 0) {
1521 int saved_errno
= errno
;
1522 rollback_index_files();
1523 die(_("could not read commit message: %s"), strerror(saved_errno
));
1526 /* Truncate the message just before the diff, if any. */
1528 p
= strstr(sb
.buf
, "\ndiff --git ");
1530 strbuf_setlen(&sb
, p
- sb
.buf
+ 1);
1533 if (cleanup_mode
!= CLEANUP_NONE
)
1534 stripspace(&sb
, cleanup_mode
== CLEANUP_ALL
);
1535 if (template_untouched(&sb
) && !allow_empty_message
) {
1536 rollback_index_files();
1537 fprintf(stderr
, _("Aborting commit; you did not edit the message.\n"));
1540 if (message_is_empty(&sb
) && !allow_empty_message
) {
1541 rollback_index_files();
1542 fprintf(stderr
, _("Aborting commit due to empty commit message.\n"));
1547 const char *exclude_gpgsig
[2] = { "gpgsig", NULL
};
1548 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1550 struct commit_extra_header
**tail
= &extra
;
1551 append_merge_tag_headers(parents
, &tail
);
1554 if (commit_tree_extended(&sb
, active_cache_tree
->sha1
, parents
, sha1
,
1555 author_ident
.buf
, sign_commit
, extra
)) {
1556 rollback_index_files();
1557 die(_("failed to write commit object"));
1559 strbuf_release(&author_ident
);
1560 free_commit_extra_headers(extra
);
1562 ref_lock
= lock_any_ref_for_update("HEAD",
1565 : current_head
->object
.sha1
,
1568 nl
= strchr(sb
.buf
, '\n');
1570 strbuf_setlen(&sb
, nl
+ 1 - sb
.buf
);
1572 strbuf_addch(&sb
, '\n');
1573 strbuf_insert(&sb
, 0, reflog_msg
, strlen(reflog_msg
));
1574 strbuf_insert(&sb
, strlen(reflog_msg
), ": ", 2);
1577 rollback_index_files();
1578 die(_("cannot lock HEAD ref"));
1580 if (write_ref_sha1(ref_lock
, sha1
, sb
.buf
) < 0) {
1581 rollback_index_files();
1582 die(_("cannot update HEAD ref"));
1585 unlink(git_path("CHERRY_PICK_HEAD"));
1586 unlink(git_path("REVERT_HEAD"));
1587 unlink(git_path("MERGE_HEAD"));
1588 unlink(git_path("MERGE_MSG"));
1589 unlink(git_path("MERGE_MODE"));
1590 unlink(git_path("SQUASH_MSG"));
1592 if (commit_index_files())
1593 die (_("Repository has been updated, but unable to write\n"
1594 "new_index file. Check that disk is not full or quota is\n"
1595 "not exceeded, and then \"git reset HEAD\" to recover."));
1598 run_hook(get_index_file(), "post-commit", NULL
);
1599 if (amend
&& !no_post_rewrite
) {
1600 struct notes_rewrite_cfg
*cfg
;
1601 cfg
= init_copy_notes_for_rewrite("amend");
1603 /* we are amending, so current_head is not NULL */
1604 copy_note_for_rewrite(cfg
, current_head
->object
.sha1
, sha1
);
1605 finish_copy_notes_for_rewrite(cfg
);
1607 run_rewrite_hook(current_head
->object
.sha1
, sha1
);
1610 print_summary(prefix
, sha1
, !current_head
);