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 len
= eol
- (rb
+ strlen("> "));
530 date
= xmalloc(len
+ 2);
532 memcpy(date
+ 1, rb
+ strlen("> "), len
);
533 date
[len
+ 1] = '\0';
537 const char *lb
= strstr(force_author
, " <");
538 const char *rb
= strchr(force_author
, '>');
541 die(_("malformed --author parameter"));
542 name
= xstrndup(force_author
, lb
- force_author
);
543 email
= xstrndup(lb
+ 2, rb
- (lb
+ 2));
548 strbuf_addstr(author_ident
, fmt_ident(name
, email
, date
, IDENT_STRICT
));
549 if (!split_ident_line(&author
, author_ident
->buf
, author_ident
->len
) &&
550 sane_ident_split(&author
)) {
551 export_one("GIT_AUTHOR_NAME", author
.name_begin
, author
.name_end
, 0);
552 export_one("GIT_AUTHOR_EMAIL", author
.mail_begin
, author
.mail_end
, 0);
553 export_one("GIT_AUTHOR_DATE", author
.date_begin
, author
.tz_end
, '@');
557 static char *cut_ident_timestamp_part(char *string
)
559 char *ket
= strrchr(string
, '>');
560 if (!ket
|| ket
[1] != ' ')
561 die(_("Malformed ident string: '%s'"), string
);
566 static int prepare_to_commit(const char *index_file
, const char *prefix
,
567 struct commit
*current_head
,
569 struct strbuf
*author_ident
)
572 struct strbuf committer_ident
= STRBUF_INIT
;
573 int commitable
, saved_color_setting
;
574 struct strbuf sb
= STRBUF_INIT
;
576 const char *hook_arg1
= NULL
;
577 const char *hook_arg2
= NULL
;
579 int clean_message_contents
= (cleanup_mode
!= CLEANUP_NONE
);
581 /* This checks and barfs if author is badly specified */
582 determine_author_info(author_ident
);
584 if (!no_verify
&& run_hook(index_file
, "pre-commit", NULL
))
587 if (squash_message
) {
589 * Insert the proper subject line before other commit
590 * message options add their content.
592 if (use_message
&& !strcmp(use_message
, squash_message
))
593 strbuf_addstr(&sb
, "squash! ");
595 struct pretty_print_context ctx
= {0};
597 c
= lookup_commit_reference_by_name(squash_message
);
599 die(_("could not lookup commit %s"), squash_message
);
600 ctx
.output_encoding
= get_commit_output_encoding();
601 format_commit_message(c
, "squash! %s\n\n", &sb
,
607 strbuf_addbuf(&sb
, &message
);
608 hook_arg1
= "message";
609 } else if (logfile
&& !strcmp(logfile
, "-")) {
611 fprintf(stderr
, _("(reading log message from standard input)\n"));
612 if (strbuf_read(&sb
, 0, 0) < 0)
613 die_errno(_("could not read log from standard input"));
614 hook_arg1
= "message";
615 } else if (logfile
) {
616 if (strbuf_read_file(&sb
, logfile
, 0) < 0)
617 die_errno(_("could not read log file '%s'"),
619 hook_arg1
= "message";
620 } else if (use_message
) {
621 buffer
= strstr(use_message_buffer
, "\n\n");
622 if (!use_editor
&& (!buffer
|| buffer
[2] == '\0'))
623 die(_("commit has empty message"));
624 strbuf_add(&sb
, buffer
+ 2, strlen(buffer
+ 2));
625 hook_arg1
= "commit";
626 hook_arg2
= use_message
;
627 } else if (fixup_message
) {
628 struct pretty_print_context ctx
= {0};
629 struct commit
*commit
;
630 commit
= lookup_commit_reference_by_name(fixup_message
);
632 die(_("could not lookup commit %s"), fixup_message
);
633 ctx
.output_encoding
= get_commit_output_encoding();
634 format_commit_message(commit
, "fixup! %s\n\n",
636 hook_arg1
= "message";
637 } else if (!stat(git_path("MERGE_MSG"), &statbuf
)) {
638 if (strbuf_read_file(&sb
, git_path("MERGE_MSG"), 0) < 0)
639 die_errno(_("could not read MERGE_MSG"));
641 } else if (!stat(git_path("SQUASH_MSG"), &statbuf
)) {
642 if (strbuf_read_file(&sb
, git_path("SQUASH_MSG"), 0) < 0)
643 die_errno(_("could not read SQUASH_MSG"));
644 hook_arg1
= "squash";
645 } else if (template_file
) {
646 if (strbuf_read_file(&sb
, template_file
, 0) < 0)
647 die_errno(_("could not read '%s'"), template_file
);
648 hook_arg1
= "template";
649 clean_message_contents
= 0;
653 * The remaining cases don't modify the template message, but
654 * just set the argument(s) to the prepare-commit-msg hook.
656 else if (whence
== FROM_MERGE
)
658 else if (whence
== FROM_CHERRY_PICK
) {
659 hook_arg1
= "commit";
660 hook_arg2
= "CHERRY_PICK_HEAD";
663 if (squash_message
) {
665 * If squash_commit was used for the commit subject,
666 * then we're possibly hijacking other commit log options.
667 * Reset the hook args to tell the real story.
669 hook_arg1
= "message";
673 s
->fp
= fopen(git_path(commit_editmsg
), "w");
675 die_errno(_("could not open '%s'"), git_path(commit_editmsg
));
677 if (clean_message_contents
)
682 * See if we have a Conflicts: block at the end. If yes, count
683 * its size, so we can ignore it.
685 int ignore_footer
= 0;
686 int i
, eol
, previous
= 0;
689 for (i
= 0; i
< sb
.len
; i
++) {
690 nl
= memchr(sb
.buf
+ i
, '\n', sb
.len
- i
);
695 if (!prefixcmp(sb
.buf
+ previous
, "\nConflicts:\n")) {
696 ignore_footer
= sb
.len
- previous
;
704 append_signoff(&sb
, ignore_footer
);
707 if (fwrite(sb
.buf
, 1, sb
.len
, s
->fp
) < sb
.len
)
708 die_errno(_("could not write commit template"));
712 /* This checks if committer ident is explicitly given */
713 strbuf_addstr(&committer_ident
, git_committer_info(IDENT_STRICT
));
714 if (use_editor
&& include_status
) {
715 char *ai_tmp
, *ci_tmp
;
716 if (whence
!= FROM_COMMIT
)
717 status_printf_ln(s
, GIT_COLOR_NORMAL
,
720 "It looks like you may be committing a merge.\n"
721 "If this is not correct, please remove the file\n"
725 "It looks like you may be committing a cherry-pick.\n"
726 "If this is not correct, please remove the file\n"
729 git_path(whence
== FROM_MERGE
731 : "CHERRY_PICK_HEAD"));
733 fprintf(s
->fp
, "\n");
734 if (cleanup_mode
== CLEANUP_ALL
)
735 status_printf(s
, GIT_COLOR_NORMAL
,
736 _("Please enter the commit message for your changes."
737 " Lines starting\nwith '%c' will be ignored, and an empty"
738 " message aborts the commit.\n"), comment_line_char
);
739 else /* CLEANUP_SPACE, that is. */
740 status_printf(s
, GIT_COLOR_NORMAL
,
741 _("Please enter the commit message for your changes."
743 "with '%c' will be kept; you may remove them"
744 " yourself if you want to.\n"
745 "An empty message aborts the commit.\n"), comment_line_char
);
746 if (only_include_assumed
)
747 status_printf_ln(s
, GIT_COLOR_NORMAL
,
748 "%s", only_include_assumed
);
750 ai_tmp
= cut_ident_timestamp_part(author_ident
->buf
);
751 ci_tmp
= cut_ident_timestamp_part(committer_ident
.buf
);
752 if (strcmp(author_ident
->buf
, committer_ident
.buf
))
753 status_printf_ln(s
, GIT_COLOR_NORMAL
,
756 ident_shown
++ ? "" : "\n",
759 if (!committer_ident_sufficiently_given())
760 status_printf_ln(s
, GIT_COLOR_NORMAL
,
763 ident_shown
++ ? "" : "\n",
764 committer_ident
.buf
);
767 status_printf_ln(s
, GIT_COLOR_NORMAL
, "");
769 saved_color_setting
= s
->use_color
;
771 commitable
= run_status(s
->fp
, index_file
, prefix
, 1, s
);
772 s
->use_color
= saved_color_setting
;
777 unsigned char sha1
[20];
778 const char *parent
= "HEAD";
780 if (!active_nr
&& read_cache() < 0)
781 die(_("Cannot read index"));
786 if (get_sha1(parent
, sha1
))
787 commitable
= !!active_nr
;
789 commitable
= index_differs_from(parent
, 0);
791 strbuf_release(&committer_ident
);
796 * Reject an attempt to record a non-merge empty commit without
797 * explicit --allow-empty. In the cherry-pick case, it may be
798 * empty due to conflict resolution, which the user should okay.
800 if (!commitable
&& whence
!= FROM_MERGE
&& !allow_empty
&&
801 !(amend
&& is_a_merge(current_head
))) {
802 run_status(stdout
, index_file
, prefix
, 0, s
);
804 fputs(_(empty_amend_advice
), stderr
);
805 else if (whence
== FROM_CHERRY_PICK
)
806 fputs(_(empty_cherry_pick_advice
), stderr
);
811 * Re-read the index as pre-commit hook could have updated it,
812 * and write it out as a tree. We must do this before we invoke
813 * the editor and after we invoke run_status above.
816 read_cache_from(index_file
);
817 if (update_main_cache_tree(0)) {
818 error(_("Error building trees"));
822 if (run_hook(index_file
, "prepare-commit-msg",
823 git_path(commit_editmsg
), hook_arg1
, hook_arg2
, NULL
))
827 char index
[PATH_MAX
];
828 const char *env
[2] = { NULL
};
830 snprintf(index
, sizeof(index
), "GIT_INDEX_FILE=%s", index_file
);
831 if (launch_editor(git_path(commit_editmsg
), NULL
, env
)) {
833 _("Please supply the message using either -m or -F option.\n"));
839 run_hook(index_file
, "commit-msg", git_path(commit_editmsg
), NULL
)) {
846 static int rest_is_empty(struct strbuf
*sb
, int start
)
851 /* Check if the rest is just whitespace and Signed-of-by's. */
852 for (i
= start
; i
< sb
->len
; i
++) {
853 nl
= memchr(sb
->buf
+ i
, '\n', sb
->len
- i
);
859 if (strlen(sign_off_header
) <= eol
- i
&&
860 !prefixcmp(sb
->buf
+ i
, sign_off_header
)) {
865 if (!isspace(sb
->buf
[i
++]))
873 * Find out if the message in the strbuf contains only whitespace and
874 * Signed-off-by lines.
876 static int message_is_empty(struct strbuf
*sb
)
878 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
880 return rest_is_empty(sb
, 0);
884 * See if the user edited the message in the editor or left what
885 * was in the template intact
887 static int template_untouched(struct strbuf
*sb
)
889 struct strbuf tmpl
= STRBUF_INIT
;
892 if (cleanup_mode
== CLEANUP_NONE
&& sb
->len
)
895 if (!template_file
|| strbuf_read_file(&tmpl
, template_file
, 0) <= 0)
898 stripspace(&tmpl
, cleanup_mode
== CLEANUP_ALL
);
899 start
= (char *)skip_prefix(sb
->buf
, tmpl
.buf
);
902 strbuf_release(&tmpl
);
903 return rest_is_empty(sb
, start
- sb
->buf
);
906 static const char *find_author_by_nickname(const char *name
)
908 struct rev_info revs
;
909 struct commit
*commit
;
910 struct strbuf buf
= STRBUF_INIT
;
914 init_revisions(&revs
, NULL
);
915 strbuf_addf(&buf
, "--author=%s", name
);
920 setup_revisions(ac
, av
, &revs
, NULL
);
921 prepare_revision_walk(&revs
);
922 commit
= get_revision(&revs
);
924 struct pretty_print_context ctx
= {0};
925 ctx
.date_mode
= DATE_NORMAL
;
926 strbuf_release(&buf
);
927 format_commit_message(commit
, "%an <%ae>", &buf
, &ctx
);
928 return strbuf_detach(&buf
, NULL
);
930 die(_("No existing author found with '%s'"), name
);
934 static void handle_untracked_files_arg(struct wt_status
*s
)
936 if (!untracked_files_arg
)
937 ; /* default already initialized */
938 else if (!strcmp(untracked_files_arg
, "no"))
939 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
940 else if (!strcmp(untracked_files_arg
, "normal"))
941 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
942 else if (!strcmp(untracked_files_arg
, "all"))
943 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
945 die(_("Invalid untracked files mode '%s'"), untracked_files_arg
);
948 static const char *read_commit_message(const char *name
)
951 struct commit
*commit
;
953 commit
= lookup_commit_reference_by_name(name
);
955 die(_("could not lookup commit %s"), name
);
956 out_enc
= get_commit_output_encoding();
957 return logmsg_reencode(commit
, out_enc
);
960 static int parse_and_validate_options(int argc
, const char *argv
[],
961 const struct option
*options
,
962 const char * const usage
[],
964 struct commit
*current_head
,
969 argc
= parse_options(argc
, argv
, prefix
, options
, usage
, 0);
971 if (force_author
&& !strchr(force_author
, '>'))
972 force_author
= find_author_by_nickname(force_author
);
974 if (force_author
&& renew_authorship
)
975 die(_("Using both --reset-author and --author does not make sense"));
977 if (logfile
|| message
.len
|| use_message
|| fixup_message
)
980 use_editor
= edit_flag
;
982 setenv("GIT_EDITOR", ":", 1);
984 /* Sanity check options */
985 if (amend
&& !current_head
)
986 die(_("You have nothing to amend."));
987 if (amend
&& whence
!= FROM_COMMIT
) {
988 if (whence
== FROM_MERGE
)
989 die(_("You are in the middle of a merge -- cannot amend."));
990 else if (whence
== FROM_CHERRY_PICK
)
991 die(_("You are in the middle of a cherry-pick -- cannot amend."));
993 if (fixup_message
&& squash_message
)
994 die(_("Options --squash and --fixup cannot be used together"));
1004 die(_("Only one of -c/-C/-F/--fixup can be used."));
1005 if (message
.len
&& f
> 0)
1006 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1007 if (f
|| message
.len
)
1008 template_file
= NULL
;
1010 use_message
= edit_message
;
1011 if (amend
&& !use_message
&& !fixup_message
)
1012 use_message
= "HEAD";
1013 if (!use_message
&& whence
!= FROM_CHERRY_PICK
&& renew_authorship
)
1014 die(_("--reset-author can be used only with -C, -c or --amend."));
1016 use_message_buffer
= read_commit_message(use_message
);
1017 if (!renew_authorship
) {
1018 author_message
= use_message
;
1019 author_message_buffer
= use_message_buffer
;
1022 if (whence
== FROM_CHERRY_PICK
&& !renew_authorship
) {
1023 author_message
= "CHERRY_PICK_HEAD";
1024 author_message_buffer
= read_commit_message(author_message
);
1027 if (patch_interactive
)
1030 if (!!also
+ !!only
+ !!all
+ !!interactive
> 1)
1031 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1032 if (argc
== 0 && (also
|| (only
&& !amend
)))
1033 die(_("No paths with --include/--only does not make sense."));
1034 if (argc
== 0 && only
&& amend
)
1035 only_include_assumed
= _("Clever... amending the last one with dirty index.");
1036 if (argc
> 0 && !also
&& !only
)
1037 only_include_assumed
= _("Explicit paths specified without -i nor -o; assuming --only paths...");
1038 if (!cleanup_arg
|| !strcmp(cleanup_arg
, "default"))
1039 cleanup_mode
= use_editor
? CLEANUP_ALL
: CLEANUP_SPACE
;
1040 else if (!strcmp(cleanup_arg
, "verbatim"))
1041 cleanup_mode
= CLEANUP_NONE
;
1042 else if (!strcmp(cleanup_arg
, "whitespace"))
1043 cleanup_mode
= CLEANUP_SPACE
;
1044 else if (!strcmp(cleanup_arg
, "strip"))
1045 cleanup_mode
= CLEANUP_ALL
;
1047 die(_("Invalid cleanup mode %s"), cleanup_arg
);
1049 handle_untracked_files_arg(s
);
1051 if (all
&& argc
> 0)
1052 die(_("Paths with -a does not make sense."));
1054 if (s
->null_termination
) {
1055 if (status_format
== STATUS_FORMAT_NONE
)
1056 status_format
= STATUS_FORMAT_PORCELAIN
;
1057 else if (status_format
== STATUS_FORMAT_LONG
)
1058 die(_("--long and -z are incompatible"));
1060 if (status_format
!= STATUS_FORMAT_NONE
)
1066 static int dry_run_commit(int argc
, const char **argv
, const char *prefix
,
1067 const struct commit
*current_head
, struct wt_status
*s
)
1070 const char *index_file
;
1072 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 1);
1073 commitable
= run_status(stdout
, index_file
, prefix
, 0, s
);
1074 rollback_index_files();
1076 return commitable
? 0 : 1;
1079 static int parse_status_slot(const char *var
, int offset
)
1081 if (!strcasecmp(var
+offset
, "header"))
1082 return WT_STATUS_HEADER
;
1083 if (!strcasecmp(var
+offset
, "branch"))
1084 return WT_STATUS_ONBRANCH
;
1085 if (!strcasecmp(var
+offset
, "updated")
1086 || !strcasecmp(var
+offset
, "added"))
1087 return WT_STATUS_UPDATED
;
1088 if (!strcasecmp(var
+offset
, "changed"))
1089 return WT_STATUS_CHANGED
;
1090 if (!strcasecmp(var
+offset
, "untracked"))
1091 return WT_STATUS_UNTRACKED
;
1092 if (!strcasecmp(var
+offset
, "nobranch"))
1093 return WT_STATUS_NOBRANCH
;
1094 if (!strcasecmp(var
+offset
, "unmerged"))
1095 return WT_STATUS_UNMERGED
;
1099 static int git_status_config(const char *k
, const char *v
, void *cb
)
1101 struct wt_status
*s
= cb
;
1103 if (!prefixcmp(k
, "column."))
1104 return git_column_config(k
, v
, "status", &s
->colopts
);
1105 if (!strcmp(k
, "status.submodulesummary")) {
1107 s
->submodule_summary
= git_config_bool_or_int(k
, v
, &is_bool
);
1108 if (is_bool
&& s
->submodule_summary
)
1109 s
->submodule_summary
= -1;
1112 if (!strcmp(k
, "status.color") || !strcmp(k
, "color.status")) {
1113 s
->use_color
= git_config_colorbool(k
, v
);
1116 if (!prefixcmp(k
, "status.color.") || !prefixcmp(k
, "color.status.")) {
1117 int slot
= parse_status_slot(k
, 13);
1121 return config_error_nonbool(k
);
1122 color_parse(v
, k
, s
->color_palette
[slot
]);
1125 if (!strcmp(k
, "status.relativepaths")) {
1126 s
->relative_paths
= git_config_bool(k
, v
);
1129 if (!strcmp(k
, "status.showuntrackedfiles")) {
1131 return config_error_nonbool(k
);
1132 else if (!strcmp(v
, "no"))
1133 s
->show_untracked_files
= SHOW_NO_UNTRACKED_FILES
;
1134 else if (!strcmp(v
, "normal"))
1135 s
->show_untracked_files
= SHOW_NORMAL_UNTRACKED_FILES
;
1136 else if (!strcmp(v
, "all"))
1137 s
->show_untracked_files
= SHOW_ALL_UNTRACKED_FILES
;
1139 return error(_("Invalid untracked files mode '%s'"), v
);
1142 return git_diff_ui_config(k
, v
, NULL
);
1145 int cmd_status(int argc
, const char **argv
, const char *prefix
)
1147 static struct wt_status s
;
1149 unsigned char sha1
[20];
1150 static struct option builtin_status_options
[] = {
1151 OPT__VERBOSE(&verbose
, N_("be verbose")),
1152 OPT_SET_INT('s', "short", &status_format
,
1153 N_("show status concisely"), STATUS_FORMAT_SHORT
),
1154 OPT_BOOLEAN('b', "branch", &s
.show_branch
,
1155 N_("show branch information")),
1156 OPT_SET_INT(0, "porcelain", &status_format
,
1157 N_("machine-readable output"),
1158 STATUS_FORMAT_PORCELAIN
),
1159 OPT_SET_INT(0, "long", &status_format
,
1160 N_("show status in long format (default)"),
1161 STATUS_FORMAT_LONG
),
1162 OPT_BOOLEAN('z', "null", &s
.null_termination
,
1163 N_("terminate entries with NUL")),
1164 { OPTION_STRING
, 'u', "untracked-files", &untracked_files_arg
,
1166 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1167 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1168 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status
,
1169 N_("show ignored files")),
1170 { OPTION_STRING
, 0, "ignore-submodules", &ignore_submodule_arg
, N_("when"),
1171 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1172 PARSE_OPT_OPTARG
, NULL
, (intptr_t)"all" },
1173 OPT_COLUMN(0, "column", &s
.colopts
, N_("list untracked files in columns")),
1177 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1178 usage_with_options(builtin_status_usage
, builtin_status_options
);
1180 wt_status_prepare(&s
);
1181 gitmodules_config();
1182 git_config(git_status_config
, &s
);
1183 determine_whence(&s
);
1184 argc
= parse_options(argc
, argv
, prefix
,
1185 builtin_status_options
,
1186 builtin_status_usage
, 0);
1187 finalize_colopts(&s
.colopts
, -1);
1189 if (s
.null_termination
) {
1190 if (status_format
== STATUS_FORMAT_NONE
)
1191 status_format
= STATUS_FORMAT_PORCELAIN
;
1192 else if (status_format
== STATUS_FORMAT_LONG
)
1193 die(_("--long and -z are incompatible"));
1196 handle_untracked_files_arg(&s
);
1197 if (show_ignored_in_status
)
1198 s
.show_ignored_files
= 1;
1200 s
.pathspec
= get_pathspec(prefix
, argv
);
1202 read_cache_preload(s
.pathspec
);
1203 refresh_index(&the_index
, REFRESH_QUIET
|REFRESH_UNMERGED
, s
.pathspec
, NULL
, NULL
);
1205 fd
= hold_locked_index(&index_lock
, 0);
1207 update_index_if_able(&the_index
, &index_lock
);
1209 s
.is_initial
= get_sha1(s
.reference
, sha1
) ? 1 : 0;
1210 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1211 wt_status_collect(&s
);
1213 if (s
.relative_paths
)
1216 switch (status_format
) {
1217 case STATUS_FORMAT_SHORT
:
1218 wt_shortstatus_print(&s
);
1220 case STATUS_FORMAT_PORCELAIN
:
1221 wt_porcelain_print(&s
);
1223 case STATUS_FORMAT_NONE
:
1224 case STATUS_FORMAT_LONG
:
1225 s
.verbose
= verbose
;
1226 s
.ignore_submodule_arg
= ignore_submodule_arg
;
1227 wt_status_print(&s
);
1233 static void print_summary(const char *prefix
, const unsigned char *sha1
,
1236 struct rev_info rev
;
1237 struct commit
*commit
;
1238 struct strbuf format
= STRBUF_INIT
;
1239 unsigned char junk_sha1
[20];
1241 struct pretty_print_context pctx
= {0};
1242 struct strbuf author_ident
= STRBUF_INIT
;
1243 struct strbuf committer_ident
= STRBUF_INIT
;
1245 commit
= lookup_commit(sha1
);
1247 die(_("couldn't look up newly created commit"));
1248 if (!commit
|| parse_commit(commit
))
1249 die(_("could not parse newly created commit"));
1251 strbuf_addstr(&format
, "format:%h] %s");
1253 format_commit_message(commit
, "%an <%ae>", &author_ident
, &pctx
);
1254 format_commit_message(commit
, "%cn <%ce>", &committer_ident
, &pctx
);
1255 if (strbuf_cmp(&author_ident
, &committer_ident
)) {
1256 strbuf_addstr(&format
, "\n Author: ");
1257 strbuf_addbuf_percentquote(&format
, &author_ident
);
1259 if (!committer_ident_sufficiently_given()) {
1260 strbuf_addstr(&format
, "\n Committer: ");
1261 strbuf_addbuf_percentquote(&format
, &committer_ident
);
1262 if (advice_implicit_identity
) {
1263 strbuf_addch(&format
, '\n');
1264 strbuf_addstr(&format
, _(implicit_ident_advice
));
1267 strbuf_release(&author_ident
);
1268 strbuf_release(&committer_ident
);
1270 init_revisions(&rev
, prefix
);
1271 setup_revisions(0, NULL
, &rev
, NULL
);
1274 rev
.diffopt
.output_format
=
1275 DIFF_FORMAT_SHORTSTAT
| DIFF_FORMAT_SUMMARY
;
1277 rev
.verbose_header
= 1;
1278 rev
.show_root_diff
= 1;
1279 get_commit_format(format
.buf
, &rev
);
1280 rev
.always_show_header
= 0;
1281 rev
.diffopt
.detect_rename
= 1;
1282 rev
.diffopt
.break_opt
= 0;
1283 diff_setup_done(&rev
.diffopt
);
1285 head
= resolve_ref_unsafe("HEAD", junk_sha1
, 0, NULL
);
1287 !prefixcmp(head
, "refs/heads/") ?
1289 !strcmp(head
, "HEAD") ?
1290 _("detached HEAD") :
1292 initial_commit
? _(" (root-commit)") : "");
1294 if (!log_tree_commit(&rev
, commit
)) {
1295 rev
.always_show_header
= 1;
1296 rev
.use_terminator
= 1;
1297 log_tree_commit(&rev
, commit
);
1300 strbuf_release(&format
);
1303 static int git_commit_config(const char *k
, const char *v
, void *cb
)
1305 struct wt_status
*s
= cb
;
1308 if (!strcmp(k
, "commit.template"))
1309 return git_config_pathname(&template_file
, k
, v
);
1310 if (!strcmp(k
, "commit.status")) {
1311 include_status
= git_config_bool(k
, v
);
1314 if (!strcmp(k
, "commit.cleanup"))
1315 return git_config_string(&cleanup_arg
, k
, v
);
1317 status
= git_gpg_config(k
, v
, NULL
);
1320 return git_status_config(k
, v
, s
);
1323 static int run_rewrite_hook(const unsigned char *oldsha1
,
1324 const unsigned char *newsha1
)
1326 /* oldsha1 SP newsha1 LF NUL */
1327 static char buf
[2*40 + 3];
1328 struct child_process proc
;
1329 const char *argv
[3];
1333 argv
[0] = find_hook("post-rewrite");
1340 memset(&proc
, 0, sizeof(proc
));
1343 proc
.stdout_to_stderr
= 1;
1345 code
= start_command(&proc
);
1348 n
= snprintf(buf
, sizeof(buf
), "%s %s\n",
1349 sha1_to_hex(oldsha1
), sha1_to_hex(newsha1
));
1350 write_in_full(proc
.in
, buf
, n
);
1352 return finish_command(&proc
);
1355 int cmd_commit(int argc
, const char **argv
, const char *prefix
)
1357 static struct wt_status s
;
1358 static struct option builtin_commit_options
[] = {
1359 OPT__QUIET(&quiet
, N_("suppress summary after successful commit")),
1360 OPT__VERBOSE(&verbose
, N_("show diff in commit message template")),
1362 OPT_GROUP(N_("Commit message options")),
1363 OPT_FILENAME('F', "file", &logfile
, N_("read message from file")),
1364 OPT_STRING(0, "author", &force_author
, N_("author"), N_("override author for commit")),
1365 OPT_STRING(0, "date", &force_date
, N_("date"), N_("override date for commit")),
1366 OPT_CALLBACK('m', "message", &message
, N_("message"), N_("commit message"), opt_parse_m
),
1367 OPT_STRING('c', "reedit-message", &edit_message
, N_("commit"), N_("reuse and edit message from specified commit")),
1368 OPT_STRING('C', "reuse-message", &use_message
, N_("commit"), N_("reuse message from specified commit")),
1369 OPT_STRING(0, "fixup", &fixup_message
, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1370 OPT_STRING(0, "squash", &squash_message
, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1371 OPT_BOOLEAN(0, "reset-author", &renew_authorship
, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1372 OPT_BOOLEAN('s', "signoff", &signoff
, N_("add Signed-off-by:")),
1373 OPT_FILENAME('t', "template", &template_file
, N_("use specified template file")),
1374 OPT_BOOL('e', "edit", &edit_flag
, N_("force edit of commit")),
1375 OPT_STRING(0, "cleanup", &cleanup_arg
, N_("default"), N_("how to strip spaces and #comments from message")),
1376 OPT_BOOLEAN(0, "status", &include_status
, N_("include status in commit message template")),
1377 { OPTION_STRING
, 'S', "gpg-sign", &sign_commit
, N_("key id"),
1378 N_("GPG sign commit"), PARSE_OPT_OPTARG
, NULL
, (intptr_t) "" },
1379 /* end commit message options */
1381 OPT_GROUP(N_("Commit contents options")),
1382 OPT_BOOLEAN('a', "all", &all
, N_("commit all changed files")),
1383 OPT_BOOLEAN('i', "include", &also
, N_("add specified files to index for commit")),
1384 OPT_BOOLEAN(0, "interactive", &interactive
, N_("interactively add files")),
1385 OPT_BOOLEAN('p', "patch", &patch_interactive
, N_("interactively add changes")),
1386 OPT_BOOLEAN('o', "only", &only
, N_("commit only specified files")),
1387 OPT_BOOLEAN('n', "no-verify", &no_verify
, N_("bypass pre-commit hook")),
1388 OPT_BOOLEAN(0, "dry-run", &dry_run
, N_("show what would be committed")),
1389 OPT_SET_INT(0, "short", &status_format
, N_("show status concisely"),
1390 STATUS_FORMAT_SHORT
),
1391 OPT_BOOLEAN(0, "branch", &s
.show_branch
, N_("show branch information")),
1392 OPT_SET_INT(0, "porcelain", &status_format
,
1393 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN
),
1394 OPT_SET_INT(0, "long", &status_format
,
1395 N_("show status in long format (default)"),
1396 STATUS_FORMAT_LONG
),
1397 OPT_BOOLEAN('z', "null", &s
.null_termination
,
1398 N_("terminate entries with NUL")),
1399 OPT_BOOLEAN(0, "amend", &amend
, N_("amend previous commit")),
1400 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite
, N_("bypass post-rewrite hook")),
1401 { 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" },
1402 /* end commit contents options */
1404 { OPTION_BOOLEAN
, 0, "allow-empty", &allow_empty
, NULL
,
1405 N_("ok to record an empty change"),
1406 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
1407 { OPTION_BOOLEAN
, 0, "allow-empty-message", &allow_empty_message
, NULL
,
1408 N_("ok to record a change with an empty message"),
1409 PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN
},
1414 struct strbuf sb
= STRBUF_INIT
;
1415 struct strbuf author_ident
= STRBUF_INIT
;
1416 const char *index_file
, *reflog_msg
;
1418 unsigned char sha1
[20];
1419 struct ref_lock
*ref_lock
;
1420 struct commit_list
*parents
= NULL
, **pptr
= &parents
;
1421 struct stat statbuf
;
1422 int allow_fast_forward
= 1;
1423 struct commit
*current_head
= NULL
;
1424 struct commit_extra_header
*extra
= NULL
;
1426 if (argc
== 2 && !strcmp(argv
[1], "-h"))
1427 usage_with_options(builtin_commit_usage
, builtin_commit_options
);
1429 wt_status_prepare(&s
);
1430 gitmodules_config();
1431 git_config(git_commit_config
, &s
);
1432 determine_whence(&s
);
1435 if (get_sha1("HEAD", sha1
))
1436 current_head
= NULL
;
1438 current_head
= lookup_commit_or_die(sha1
, "HEAD");
1439 if (!current_head
|| parse_commit(current_head
))
1440 die(_("could not parse HEAD commit"));
1442 argc
= parse_and_validate_options(argc
, argv
, builtin_commit_options
,
1443 builtin_commit_usage
,
1444 prefix
, current_head
, &s
);
1446 return dry_run_commit(argc
, argv
, prefix
, current_head
, &s
);
1447 index_file
= prepare_index(argc
, argv
, prefix
, current_head
, 0);
1449 /* Set up everything for writing the commit object. This includes
1450 running hooks, writing the trees, and interacting with the user. */
1451 if (!prepare_to_commit(index_file
, prefix
,
1452 current_head
, &s
, &author_ident
)) {
1453 rollback_index_files();
1457 /* Determine parents */
1458 reflog_msg
= getenv("GIT_REFLOG_ACTION");
1459 if (!current_head
) {
1461 reflog_msg
= "commit (initial)";
1463 struct commit_list
*c
;
1466 reflog_msg
= "commit (amend)";
1467 for (c
= current_head
->parents
; c
; c
= c
->next
)
1468 pptr
= &commit_list_insert(c
->item
, pptr
)->next
;
1469 } else if (whence
== FROM_MERGE
) {
1470 struct strbuf m
= STRBUF_INIT
;
1474 reflog_msg
= "commit (merge)";
1475 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1476 fp
= fopen(git_path("MERGE_HEAD"), "r");
1478 die_errno(_("could not open '%s' for reading"),
1479 git_path("MERGE_HEAD"));
1480 while (strbuf_getline(&m
, fp
, '\n') != EOF
) {
1481 struct commit
*parent
;
1483 parent
= get_merge_parent(m
.buf
);
1485 die(_("Corrupt MERGE_HEAD file (%s)"), m
.buf
);
1486 pptr
= &commit_list_insert(parent
, pptr
)->next
;
1490 if (!stat(git_path("MERGE_MODE"), &statbuf
)) {
1491 if (strbuf_read_file(&sb
, git_path("MERGE_MODE"), 0) < 0)
1492 die_errno(_("could not read MERGE_MODE"));
1493 if (!strcmp(sb
.buf
, "no-ff"))
1494 allow_fast_forward
= 0;
1496 if (allow_fast_forward
)
1497 parents
= reduce_heads(parents
);
1500 reflog_msg
= (whence
== FROM_CHERRY_PICK
)
1501 ? "commit (cherry-pick)"
1503 pptr
= &commit_list_insert(current_head
, pptr
)->next
;
1506 /* Finally, get the commit message */
1508 if (strbuf_read_file(&sb
, git_path(commit_editmsg
), 0) < 0) {
1509 int saved_errno
= errno
;
1510 rollback_index_files();
1511 die(_("could not read commit message: %s"), strerror(saved_errno
));
1514 /* Truncate the message just before the diff, if any. */
1516 p
= strstr(sb
.buf
, "\ndiff --git ");
1518 strbuf_setlen(&sb
, p
- sb
.buf
+ 1);
1521 if (cleanup_mode
!= CLEANUP_NONE
)
1522 stripspace(&sb
, cleanup_mode
== CLEANUP_ALL
);
1523 if (template_untouched(&sb
) && !allow_empty_message
) {
1524 rollback_index_files();
1525 fprintf(stderr
, _("Aborting commit; you did not edit the message.\n"));
1528 if (message_is_empty(&sb
) && !allow_empty_message
) {
1529 rollback_index_files();
1530 fprintf(stderr
, _("Aborting commit due to empty commit message.\n"));
1535 const char *exclude_gpgsig
[2] = { "gpgsig", NULL
};
1536 extra
= read_commit_extra_headers(current_head
, exclude_gpgsig
);
1538 struct commit_extra_header
**tail
= &extra
;
1539 append_merge_tag_headers(parents
, &tail
);
1542 if (commit_tree_extended(&sb
, active_cache_tree
->sha1
, parents
, sha1
,
1543 author_ident
.buf
, sign_commit
, extra
)) {
1544 rollback_index_files();
1545 die(_("failed to write commit object"));
1547 strbuf_release(&author_ident
);
1548 free_commit_extra_headers(extra
);
1550 ref_lock
= lock_any_ref_for_update("HEAD",
1553 : current_head
->object
.sha1
,
1556 nl
= strchr(sb
.buf
, '\n');
1558 strbuf_setlen(&sb
, nl
+ 1 - sb
.buf
);
1560 strbuf_addch(&sb
, '\n');
1561 strbuf_insert(&sb
, 0, reflog_msg
, strlen(reflog_msg
));
1562 strbuf_insert(&sb
, strlen(reflog_msg
), ": ", 2);
1565 rollback_index_files();
1566 die(_("cannot lock HEAD ref"));
1568 if (write_ref_sha1(ref_lock
, sha1
, sb
.buf
) < 0) {
1569 rollback_index_files();
1570 die(_("cannot update HEAD ref"));
1573 unlink(git_path("CHERRY_PICK_HEAD"));
1574 unlink(git_path("REVERT_HEAD"));
1575 unlink(git_path("MERGE_HEAD"));
1576 unlink(git_path("MERGE_MSG"));
1577 unlink(git_path("MERGE_MODE"));
1578 unlink(git_path("SQUASH_MSG"));
1580 if (commit_index_files())
1581 die (_("Repository has been updated, but unable to write\n"
1582 "new_index file. Check that disk is not full or quota is\n"
1583 "not exceeded, and then \"git reset HEAD\" to recover."));
1586 run_hook(get_index_file(), "post-commit", NULL
);
1587 if (amend
&& !no_post_rewrite
) {
1588 struct notes_rewrite_cfg
*cfg
;
1589 cfg
= init_copy_notes_for_rewrite("amend");
1591 /* we are amending, so current_head is not NULL */
1592 copy_note_for_rewrite(cfg
, current_head
->object
.sha1
, sha1
);
1593 finish_copy_notes_for_rewrite(cfg
);
1595 run_rewrite_hook(current_head
->object
.sha1
, sha1
);
1598 print_summary(prefix
, sha1
, !current_head
);