Merge branch 'jc/apply-ws-fix-tab-in-indent' into maint
[git/mingw.git] / builtin / commit.c
blobd21d07a1a8e9fbc365a4555a0f9e81d0c1f2a7d0
1 /*
2 * Builtin "git commit"
4 * Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>
5 * Based on git-commit.sh by Junio C Hamano and Linus Torvalds
6 */
8 #include "cache.h"
9 #include "cache-tree.h"
10 #include "color.h"
11 #include "dir.h"
12 #include "builtin.h"
13 #include "diff.h"
14 #include "diffcore.h"
15 #include "commit.h"
16 #include "revision.h"
17 #include "wt-status.h"
18 #include "run-command.h"
19 #include "refs.h"
20 #include "log-tree.h"
21 #include "strbuf.h"
22 #include "utf8.h"
23 #include "parse-options.h"
24 #include "string-list.h"
25 #include "rerere.h"
26 #include "unpack-trees.h"
27 #include "quote.h"
28 #include "submodule.h"
29 #include "gpg-interface.h"
30 #include "column.h"
31 #include "sequencer.h"
33 static const char * const builtin_commit_usage[] = {
34 N_("git commit [options] [--] <pathspec>..."),
35 NULL
38 static const char * const builtin_status_usage[] = {
39 N_("git status [options] [--] <pathspec>..."),
40 NULL
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"
47 "\n"
48 " git config --global user.name \"Your Name\"\n"
49 " git config --global user.email you@example.com\n"
50 "\n"
51 "After doing this, you may fix the identity used for this commit with:\n"
52 "\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"
63 "\n"
64 " git commit --allow-empty\n"
65 "\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 */
72 static enum {
73 COMMIT_AS_IS = 1,
74 COMMIT_NORMAL,
75 COMMIT_PARTIAL
76 } commit_style;
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.
101 static enum {
102 CLEANUP_SPACE,
103 CLEANUP_NONE,
104 CLEANUP_ALL
105 } cleanup_mode;
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;
114 static enum {
115 STATUS_FORMAT_NONE = 0,
116 STATUS_FORMAT_LONG,
117 STATUS_FORMAT_SHORT,
118 STATUS_FORMAT_PORCELAIN
119 } status_format;
121 static int opt_parse_m(const struct option *opt, const char *arg, int unset)
123 struct strbuf *buf = opt->value;
124 if (unset)
125 strbuf_setlen(buf, 0);
126 else {
127 if (buf->len)
128 strbuf_addch(buf, '\n');
129 strbuf_addstr(buf, arg);
130 strbuf_complete_line(buf);
132 return 0;
135 static void determine_whence(struct wt_status *s)
137 if (file_exists(git_path("MERGE_HEAD")))
138 whence = FROM_MERGE;
139 else if (file_exists(git_path("CHERRY_PICK_HEAD")))
140 whence = FROM_CHERRY_PICK;
141 else
142 whence = FROM_COMMIT;
143 if (s)
144 s->whence = whence;
147 static void rollback_index_files(void)
149 switch (commit_style) {
150 case COMMIT_AS_IS:
151 break; /* nothing to do */
152 case COMMIT_NORMAL:
153 rollback_lock_file(&index_lock);
154 break;
155 case COMMIT_PARTIAL:
156 rollback_lock_file(&index_lock);
157 rollback_lock_file(&false_lock);
158 break;
162 static int commit_index_files(void)
164 int err = 0;
166 switch (commit_style) {
167 case COMMIT_AS_IS:
168 break; /* nothing to do */
169 case COMMIT_NORMAL:
170 err = commit_lock_file(&index_lock);
171 break;
172 case COMMIT_PARTIAL:
173 err = commit_lock_file(&index_lock);
174 rollback_lock_file(&false_lock);
175 break;
178 return err;
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)
188 int i;
189 char *m;
191 if (!pattern)
192 return 0;
194 for (i = 0; pattern[i]; i++)
196 m = xcalloc(1, i);
198 if (with_tree) {
199 char *max_prefix = common_prefix(pattern);
200 overlay_tree_on_cache(with_tree, max_prefix ? max_prefix : prefix);
201 free(max_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)
209 continue;
210 if (!match_pathspec(pattern, ce->name, ce_namelen(ce), 0, m))
211 continue;
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)
222 int i;
223 for (i = 0; i < list->nr; i++) {
224 struct stat st;
225 struct string_list_item *p = &(list->items[i]);
227 /* p->util is skip-worktree */
228 if (p->util)
229 continue;
231 if (!lstat(p->string, &st)) {
232 if (add_to_cache(p->string, &st, 0))
233 die(_("updating files failed"));
234 } else
235 remove_file_from_cache(p->string);
239 static void create_base_index(const struct commit *current_head)
241 struct tree *tree;
242 struct unpack_trees_options opts;
243 struct tree_desc t;
245 if (!current_head) {
246 discard_cache();
247 return;
250 memset(&opts, 0, sizeof(opts));
251 opts.head_idx = 1;
252 opts.index_only = 1;
253 opts.merge = 1;
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);
259 if (!tree)
260 die(_("failed to unpack HEAD tree object"));
261 parse_tree(tree);
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)
280 int fd;
281 struct string_list partial;
282 const char **pathspec = NULL;
283 char *old_index_env = NULL;
284 int refresh_flags = REFRESH_QUIET;
286 if (is_status)
287 refresh_flags |= REFRESH_UNMERGED;
289 if (*argv)
290 pathspec = get_pathspec(prefix, argv);
292 if (read_cache_preload(pathspec) < 0)
293 die(_("index file corrupt"));
295 if (interactive) {
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);
312 else
313 unsetenv(INDEX_ENVIRONMENT);
315 discard_cache();
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;
347 * As-is commit.
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"));
363 } else {
364 rollback_lock_file(&index_lock);
366 commit_style = COMMIT_AS_IS;
367 return get_index_file();
371 * A partial commit.
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))
401 exit(1);
403 discard_cache();
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()),
417 LOCK_DIE_ON_ERROR);
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"));
427 discard_cache();
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,
434 struct wt_status *s)
436 unsigned char sha1[20];
438 if (s->relative_paths)
439 s->prefix = prefix;
441 if (amend) {
442 s->amend = 1;
443 s->reference = "HEAD^1";
445 s->verbose = verbose;
446 s->index_file = index_file;
447 s->fp = fp;
448 s->nowarn = nowarn;
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);
456 break;
457 case STATUS_FORMAT_PORCELAIN:
458 wt_porcelain_print(s);
459 break;
460 case STATUS_FORMAT_NONE:
461 case STATUS_FORMAT_LONG:
462 wt_status_print(s);
463 break;
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;
477 if (hack)
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)
494 return 0;
495 return 1;
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;
509 size_t len;
511 a = strstr(author_message_buffer, "\nauthor ");
512 if (!a)
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);
524 else
525 name = xmemdupz(a + strlen("\nauthor "),
526 (lb - strlen(" ") -
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);
532 *date = '@';
533 memcpy(date + 1, rb + strlen("> "), len);
534 date[len + 1] = '\0';
537 if (force_author) {
538 const char *lb = strstr(force_author, " <");
539 const char *rb = strchr(force_author, '>');
541 if (!lb || !rb)
542 die(_("malformed --author parameter"));
543 name = xstrndup(force_author, lb - force_author);
544 email = xstrndup(lb + 2, rb - (lb + 2));
547 if (force_date)
548 date = force_date;
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);
563 *++ket = '\0';
564 return ket;
567 static int prepare_to_commit(const char *index_file, const char *prefix,
568 struct commit *current_head,
569 struct wt_status *s,
570 struct strbuf *author_ident)
572 struct stat statbuf;
573 struct strbuf committer_ident = STRBUF_INIT;
574 int commitable, saved_color_setting;
575 struct strbuf sb = STRBUF_INIT;
576 char *buffer;
577 const char *hook_arg1 = NULL;
578 const char *hook_arg2 = NULL;
579 int ident_shown = 0;
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))
586 return 0;
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! ");
595 else {
596 struct pretty_print_context ctx = {0};
597 struct commit *c;
598 c = lookup_commit_reference_by_name(squash_message);
599 if (!c)
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,
603 &ctx);
607 if (message.len) {
608 strbuf_addbuf(&sb, &message);
609 hook_arg1 = "message";
610 } else if (logfile && !strcmp(logfile, "-")) {
611 if (isatty(0))
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'"),
619 logfile);
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);
632 if (!commit)
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",
636 &sb, &ctx);
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"));
641 hook_arg1 = "merge";
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)
658 hook_arg1 = "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";
671 hook_arg2 = "";
674 s->fp = fopen(git_path(commit_editmsg), "w");
675 if (s->fp == NULL)
676 die_errno(_("could not open '%s'"), git_path(commit_editmsg));
678 if (clean_message_contents)
679 stripspace(&sb, 0);
681 if (signoff) {
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;
688 const char *nl;
690 for (i = 0; i < sb.len; i++) {
691 nl = memchr(sb.buf + i, '\n', sb.len - i);
692 if (nl)
693 eol = nl - sb.buf;
694 else
695 eol = sb.len;
696 if (!prefixcmp(sb.buf + previous, "\nConflicts:\n")) {
697 ignore_footer = sb.len - previous;
698 break;
700 while (i < eol)
701 i++;
702 previous = eol;
705 append_signoff(&sb, ignore_footer);
708 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
709 die_errno(_("could not write commit template"));
711 strbuf_release(&sb);
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,
719 whence == FROM_MERGE
720 ? _("\n"
721 "It looks like you may be committing a merge.\n"
722 "If this is not correct, please remove the file\n"
723 " %s\n"
724 "and try again.\n")
725 : _("\n"
726 "It looks like you may be committing a cherry-pick.\n"
727 "If this is not correct, please remove the file\n"
728 " %s\n"
729 "and try again.\n"),
730 git_path(whence == FROM_MERGE
731 ? "MERGE_HEAD"
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."
743 " Lines starting\n"
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,
755 _("%s"
756 "Author: %s"),
757 ident_shown++ ? "" : "\n",
758 author_ident->buf);
760 if (!committer_ident_sufficiently_given())
761 status_printf_ln(s, GIT_COLOR_NORMAL,
762 _("%s"
763 "Committer: %s"),
764 ident_shown++ ? "" : "\n",
765 committer_ident.buf);
767 if (ident_shown)
768 status_printf_ln(s, GIT_COLOR_NORMAL, "");
770 saved_color_setting = s->use_color;
771 s->use_color = 0;
772 commitable = run_status(s->fp, index_file, prefix, 1, s);
773 s->use_color = saved_color_setting;
775 *ai_tmp = ' ';
776 *ci_tmp = ' ';
777 } else {
778 unsigned char sha1[20];
779 const char *parent = "HEAD";
781 if (!active_nr && read_cache() < 0)
782 die(_("Cannot read index"));
784 if (amend)
785 parent = "HEAD^1";
787 if (get_sha1(parent, sha1))
788 commitable = !!active_nr;
789 else
790 commitable = index_differs_from(parent, 0);
792 strbuf_release(&committer_ident);
794 fclose(s->fp);
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);
804 if (amend)
805 fputs(_(empty_amend_advice), stderr);
806 else if (whence == FROM_CHERRY_PICK)
807 fputs(_(empty_cherry_pick_advice), stderr);
808 return 0;
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.
816 discard_cache();
817 read_cache_from(index_file);
818 if (update_main_cache_tree(0)) {
819 error(_("Error building trees"));
820 return 0;
823 if (run_hook(index_file, "prepare-commit-msg",
824 git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
825 return 0;
827 if (use_editor) {
828 char index[PATH_MAX];
829 const char *env[2] = { NULL };
830 env[0] = index;
831 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
832 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
833 fprintf(stderr,
834 _("Please supply the message using either -m or -F option.\n"));
835 exit(1);
839 if (!no_verify &&
840 run_hook(index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
841 return 0;
844 return 1;
847 static int rest_is_empty(struct strbuf *sb, int start)
849 int i, eol;
850 const char *nl;
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);
855 if (nl)
856 eol = nl - sb->buf;
857 else
858 eol = sb->len;
860 if (strlen(sign_off_header) <= eol - i &&
861 !prefixcmp(sb->buf + i, sign_off_header)) {
862 i = eol;
863 continue;
865 while (i < eol)
866 if (!isspace(sb->buf[i++]))
867 return 0;
870 return 1;
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)
880 return 0;
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;
891 char *start;
893 if (cleanup_mode == CLEANUP_NONE && sb->len)
894 return 0;
896 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
897 return 0;
899 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
900 start = (char *)skip_prefix(sb->buf, tmpl.buf);
901 if (!start)
902 start = sb->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;
912 const char *av[20];
913 int ac = 0;
915 init_revisions(&revs, NULL);
916 strbuf_addf(&buf, "--author=%s", name);
917 av[++ac] = "--all";
918 av[++ac] = "-i";
919 av[++ac] = buf.buf;
920 av[++ac] = NULL;
921 setup_revisions(ac, av, &revs, NULL);
922 prepare_revision_walk(&revs);
923 commit = get_revision(&revs);
924 if (commit) {
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;
945 else
946 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
949 static const char *read_commit_message(const char *name)
951 const char *out_enc;
952 struct commit *commit;
954 commit = lookup_commit_reference_by_name(name);
955 if (!commit)
956 die(_("could not lookup commit %s"), name);
957 out_enc = get_commit_output_encoding();
958 return logmsg_reencode(commit, out_enc);
961 static int parse_and_validate_options(int argc, const char *argv[],
962 const struct option *options,
963 const char * const usage[],
964 const char *prefix,
965 struct commit *current_head,
966 struct wt_status *s)
968 int f = 0;
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)
979 use_editor = 0;
980 if (0 <= edit_flag)
981 use_editor = edit_flag;
982 if (!use_editor)
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"));
996 if (use_message)
997 f++;
998 if (edit_message)
999 f++;
1000 if (fixup_message)
1001 f++;
1002 if (logfile)
1003 f++;
1004 if (f > 1)
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;
1010 if (edit_message)
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."));
1016 if (use_message) {
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)
1029 interactive = 1;
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;
1047 else
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)
1062 dry_run = 1;
1064 return argc;
1067 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1068 const struct commit *current_head, struct wt_status *s)
1070 int commitable;
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;
1097 return -1;
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")) {
1107 int is_bool;
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;
1111 return 0;
1113 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1114 s->use_color = git_config_colorbool(k, v);
1115 return 0;
1117 if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
1118 int slot = parse_status_slot(k, 13);
1119 if (slot < 0)
1120 return 0;
1121 if (!v)
1122 return config_error_nonbool(k);
1123 color_parse(v, k, s->color_palette[slot]);
1124 return 0;
1126 if (!strcmp(k, "status.relativepaths")) {
1127 s->relative_paths = git_config_bool(k, v);
1128 return 0;
1130 if (!strcmp(k, "status.showuntrackedfiles")) {
1131 if (!v)
1132 return config_error_nonbool(k);
1133 else if (!strcmp(v, "no"))
1134 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1135 else if (!strcmp(v, "normal"))
1136 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1137 else if (!strcmp(v, "all"))
1138 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1139 else
1140 return error(_("Invalid untracked files mode '%s'"), v);
1141 return 0;
1143 return git_diff_ui_config(k, v, NULL);
1146 int cmd_status(int argc, const char **argv, const char *prefix)
1148 static struct wt_status s;
1149 int fd;
1150 unsigned char sha1[20];
1151 static struct option builtin_status_options[] = {
1152 OPT__VERBOSE(&verbose, N_("be verbose")),
1153 OPT_SET_INT('s', "short", &status_format,
1154 N_("show status concisely"), STATUS_FORMAT_SHORT),
1155 OPT_BOOLEAN('b', "branch", &s.show_branch,
1156 N_("show branch information")),
1157 OPT_SET_INT(0, "porcelain", &status_format,
1158 N_("machine-readable output"),
1159 STATUS_FORMAT_PORCELAIN),
1160 OPT_SET_INT(0, "long", &status_format,
1161 N_("show status in long format (default)"),
1162 STATUS_FORMAT_LONG),
1163 OPT_BOOLEAN('z', "null", &s.null_termination,
1164 N_("terminate entries with NUL")),
1165 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1166 N_("mode"),
1167 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
1168 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1169 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status,
1170 N_("show ignored files")),
1171 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when"),
1172 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
1173 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1174 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
1175 OPT_END(),
1178 if (argc == 2 && !strcmp(argv[1], "-h"))
1179 usage_with_options(builtin_status_usage, builtin_status_options);
1181 wt_status_prepare(&s);
1182 gitmodules_config();
1183 git_config(git_status_config, &s);
1184 determine_whence(&s);
1185 argc = parse_options(argc, argv, prefix,
1186 builtin_status_options,
1187 builtin_status_usage, 0);
1188 finalize_colopts(&s.colopts, -1);
1190 if (s.null_termination) {
1191 if (status_format == STATUS_FORMAT_NONE)
1192 status_format = STATUS_FORMAT_PORCELAIN;
1193 else if (status_format == STATUS_FORMAT_LONG)
1194 die(_("--long and -z are incompatible"));
1197 handle_untracked_files_arg(&s);
1198 if (show_ignored_in_status)
1199 s.show_ignored_files = 1;
1200 if (*argv)
1201 s.pathspec = get_pathspec(prefix, argv);
1203 read_cache_preload(s.pathspec);
1204 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);
1206 fd = hold_locked_index(&index_lock, 0);
1207 if (0 <= fd)
1208 update_index_if_able(&the_index, &index_lock);
1210 s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1211 s.ignore_submodule_arg = ignore_submodule_arg;
1212 wt_status_collect(&s);
1214 if (s.relative_paths)
1215 s.prefix = prefix;
1217 switch (status_format) {
1218 case STATUS_FORMAT_SHORT:
1219 wt_shortstatus_print(&s);
1220 break;
1221 case STATUS_FORMAT_PORCELAIN:
1222 wt_porcelain_print(&s);
1223 break;
1224 case STATUS_FORMAT_NONE:
1225 case STATUS_FORMAT_LONG:
1226 s.verbose = verbose;
1227 s.ignore_submodule_arg = ignore_submodule_arg;
1228 wt_status_print(&s);
1229 break;
1231 return 0;
1234 static void print_summary(const char *prefix, const unsigned char *sha1,
1235 int initial_commit)
1237 struct rev_info rev;
1238 struct commit *commit;
1239 struct strbuf format = STRBUF_INIT;
1240 unsigned char junk_sha1[20];
1241 const char *head;
1242 struct pretty_print_context pctx = {0};
1243 struct strbuf author_ident = STRBUF_INIT;
1244 struct strbuf committer_ident = STRBUF_INIT;
1246 commit = lookup_commit(sha1);
1247 if (!commit)
1248 die(_("couldn't look up newly created commit"));
1249 if (!commit || parse_commit(commit))
1250 die(_("could not parse newly created commit"));
1252 strbuf_addstr(&format, "format:%h] %s");
1254 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1255 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1256 if (strbuf_cmp(&author_ident, &committer_ident)) {
1257 strbuf_addstr(&format, "\n Author: ");
1258 strbuf_addbuf_percentquote(&format, &author_ident);
1260 if (!committer_ident_sufficiently_given()) {
1261 strbuf_addstr(&format, "\n Committer: ");
1262 strbuf_addbuf_percentquote(&format, &committer_ident);
1263 if (advice_implicit_identity) {
1264 strbuf_addch(&format, '\n');
1265 strbuf_addstr(&format, _(implicit_ident_advice));
1268 strbuf_release(&author_ident);
1269 strbuf_release(&committer_ident);
1271 init_revisions(&rev, prefix);
1272 setup_revisions(0, NULL, &rev, NULL);
1274 rev.diff = 1;
1275 rev.diffopt.output_format =
1276 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1278 rev.verbose_header = 1;
1279 rev.show_root_diff = 1;
1280 get_commit_format(format.buf, &rev);
1281 rev.always_show_header = 0;
1282 rev.diffopt.detect_rename = 1;
1283 rev.diffopt.break_opt = 0;
1284 diff_setup_done(&rev.diffopt);
1286 head = resolve_ref_unsafe("HEAD", junk_sha1, 0, NULL);
1287 printf("[%s%s ",
1288 !prefixcmp(head, "refs/heads/") ?
1289 head + 11 :
1290 !strcmp(head, "HEAD") ?
1291 _("detached HEAD") :
1292 head,
1293 initial_commit ? _(" (root-commit)") : "");
1295 if (!log_tree_commit(&rev, commit)) {
1296 rev.always_show_header = 1;
1297 rev.use_terminator = 1;
1298 log_tree_commit(&rev, commit);
1301 strbuf_release(&format);
1304 static int git_commit_config(const char *k, const char *v, void *cb)
1306 struct wt_status *s = cb;
1307 int status;
1309 if (!strcmp(k, "commit.template"))
1310 return git_config_pathname(&template_file, k, v);
1311 if (!strcmp(k, "commit.status")) {
1312 include_status = git_config_bool(k, v);
1313 return 0;
1315 if (!strcmp(k, "commit.cleanup"))
1316 return git_config_string(&cleanup_arg, k, v);
1318 status = git_gpg_config(k, v, NULL);
1319 if (status)
1320 return status;
1321 return git_status_config(k, v, s);
1324 static int run_rewrite_hook(const unsigned char *oldsha1,
1325 const unsigned char *newsha1)
1327 /* oldsha1 SP newsha1 LF NUL */
1328 static char buf[2*40 + 3];
1329 struct child_process proc;
1330 const char *argv[3];
1331 int code;
1332 size_t n;
1334 argv[0] = find_hook("post-rewrite");
1335 if (!argv[0])
1336 return 0;
1338 argv[1] = "amend";
1339 argv[2] = NULL;
1341 memset(&proc, 0, sizeof(proc));
1342 proc.argv = argv;
1343 proc.in = -1;
1344 proc.stdout_to_stderr = 1;
1346 code = start_command(&proc);
1347 if (code)
1348 return code;
1349 n = snprintf(buf, sizeof(buf), "%s %s\n",
1350 sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1351 write_in_full(proc.in, buf, n);
1352 close(proc.in);
1353 return finish_command(&proc);
1356 int cmd_commit(int argc, const char **argv, const char *prefix)
1358 static struct wt_status s;
1359 static struct option builtin_commit_options[] = {
1360 OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1361 OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
1363 OPT_GROUP(N_("Commit message options")),
1364 OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1365 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1366 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1367 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1368 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1369 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1370 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1371 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
1372 OPT_BOOLEAN(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1373 OPT_BOOLEAN('s', "signoff", &signoff, N_("add Signed-off-by:")),
1374 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1375 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
1376 OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
1377 OPT_BOOLEAN(0, "status", &include_status, N_("include status in commit message template")),
1378 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key id"),
1379 N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
1380 /* end commit message options */
1382 OPT_GROUP(N_("Commit contents options")),
1383 OPT_BOOLEAN('a', "all", &all, N_("commit all changed files")),
1384 OPT_BOOLEAN('i', "include", &also, N_("add specified files to index for commit")),
1385 OPT_BOOLEAN(0, "interactive", &interactive, N_("interactively add files")),
1386 OPT_BOOLEAN('p', "patch", &patch_interactive, N_("interactively add changes")),
1387 OPT_BOOLEAN('o', "only", &only, N_("commit only specified files")),
1388 OPT_BOOLEAN('n', "no-verify", &no_verify, N_("bypass pre-commit hook")),
1389 OPT_BOOLEAN(0, "dry-run", &dry_run, N_("show what would be committed")),
1390 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
1391 STATUS_FORMAT_SHORT),
1392 OPT_BOOLEAN(0, "branch", &s.show_branch, N_("show branch information")),
1393 OPT_SET_INT(0, "porcelain", &status_format,
1394 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
1395 OPT_SET_INT(0, "long", &status_format,
1396 N_("show status in long format (default)"),
1397 STATUS_FORMAT_LONG),
1398 OPT_BOOLEAN('z', "null", &s.null_termination,
1399 N_("terminate entries with NUL")),
1400 OPT_BOOLEAN(0, "amend", &amend, N_("amend previous commit")),
1401 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
1402 { 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" },
1403 /* end commit contents options */
1405 { OPTION_BOOLEAN, 0, "allow-empty", &allow_empty, NULL,
1406 N_("ok to record an empty change"),
1407 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
1408 { OPTION_BOOLEAN, 0, "allow-empty-message", &allow_empty_message, NULL,
1409 N_("ok to record a change with an empty message"),
1410 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
1412 OPT_END()
1415 struct strbuf sb = STRBUF_INIT;
1416 struct strbuf author_ident = STRBUF_INIT;
1417 const char *index_file, *reflog_msg;
1418 char *nl, *p;
1419 unsigned char sha1[20];
1420 struct ref_lock *ref_lock;
1421 struct commit_list *parents = NULL, **pptr = &parents;
1422 struct stat statbuf;
1423 int allow_fast_forward = 1;
1424 struct commit *current_head = NULL;
1425 struct commit_extra_header *extra = NULL;
1427 if (argc == 2 && !strcmp(argv[1], "-h"))
1428 usage_with_options(builtin_commit_usage, builtin_commit_options);
1430 wt_status_prepare(&s);
1431 gitmodules_config();
1432 git_config(git_commit_config, &s);
1433 determine_whence(&s);
1434 s.colopts = 0;
1436 if (get_sha1("HEAD", sha1))
1437 current_head = NULL;
1438 else {
1439 current_head = lookup_commit_or_die(sha1, "HEAD");
1440 if (!current_head || parse_commit(current_head))
1441 die(_("could not parse HEAD commit"));
1443 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1444 builtin_commit_usage,
1445 prefix, current_head, &s);
1446 if (dry_run)
1447 return dry_run_commit(argc, argv, prefix, current_head, &s);
1448 index_file = prepare_index(argc, argv, prefix, current_head, 0);
1450 /* Set up everything for writing the commit object. This includes
1451 running hooks, writing the trees, and interacting with the user. */
1452 if (!prepare_to_commit(index_file, prefix,
1453 current_head, &s, &author_ident)) {
1454 rollback_index_files();
1455 return 1;
1458 /* Determine parents */
1459 reflog_msg = getenv("GIT_REFLOG_ACTION");
1460 if (!current_head) {
1461 if (!reflog_msg)
1462 reflog_msg = "commit (initial)";
1463 } else if (amend) {
1464 struct commit_list *c;
1466 if (!reflog_msg)
1467 reflog_msg = "commit (amend)";
1468 for (c = current_head->parents; c; c = c->next)
1469 pptr = &commit_list_insert(c->item, pptr)->next;
1470 } else if (whence == FROM_MERGE) {
1471 struct strbuf m = STRBUF_INIT;
1472 FILE *fp;
1474 if (!reflog_msg)
1475 reflog_msg = "commit (merge)";
1476 pptr = &commit_list_insert(current_head, pptr)->next;
1477 fp = fopen(git_path("MERGE_HEAD"), "r");
1478 if (fp == NULL)
1479 die_errno(_("could not open '%s' for reading"),
1480 git_path("MERGE_HEAD"));
1481 while (strbuf_getline(&m, fp, '\n') != EOF) {
1482 struct commit *parent;
1484 parent = get_merge_parent(m.buf);
1485 if (!parent)
1486 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1487 pptr = &commit_list_insert(parent, pptr)->next;
1489 fclose(fp);
1490 strbuf_release(&m);
1491 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1492 if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1493 die_errno(_("could not read MERGE_MODE"));
1494 if (!strcmp(sb.buf, "no-ff"))
1495 allow_fast_forward = 0;
1497 if (allow_fast_forward)
1498 parents = reduce_heads(parents);
1499 } else {
1500 if (!reflog_msg)
1501 reflog_msg = (whence == FROM_CHERRY_PICK)
1502 ? "commit (cherry-pick)"
1503 : "commit";
1504 pptr = &commit_list_insert(current_head, pptr)->next;
1507 /* Finally, get the commit message */
1508 strbuf_reset(&sb);
1509 if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1510 int saved_errno = errno;
1511 rollback_index_files();
1512 die(_("could not read commit message: %s"), strerror(saved_errno));
1515 /* Truncate the message just before the diff, if any. */
1516 if (verbose) {
1517 p = strstr(sb.buf, "\ndiff --git ");
1518 if (p != NULL)
1519 strbuf_setlen(&sb, p - sb.buf + 1);
1522 if (cleanup_mode != CLEANUP_NONE)
1523 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1524 if (template_untouched(&sb) && !allow_empty_message) {
1525 rollback_index_files();
1526 fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
1527 exit(1);
1529 if (message_is_empty(&sb) && !allow_empty_message) {
1530 rollback_index_files();
1531 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
1532 exit(1);
1535 if (amend) {
1536 const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1537 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1538 } else {
1539 struct commit_extra_header **tail = &extra;
1540 append_merge_tag_headers(parents, &tail);
1543 if (commit_tree_extended(&sb, active_cache_tree->sha1, parents, sha1,
1544 author_ident.buf, sign_commit, extra)) {
1545 rollback_index_files();
1546 die(_("failed to write commit object"));
1548 strbuf_release(&author_ident);
1549 free_commit_extra_headers(extra);
1551 ref_lock = lock_any_ref_for_update("HEAD",
1552 !current_head
1553 ? NULL
1554 : current_head->object.sha1,
1557 nl = strchr(sb.buf, '\n');
1558 if (nl)
1559 strbuf_setlen(&sb, nl + 1 - sb.buf);
1560 else
1561 strbuf_addch(&sb, '\n');
1562 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1563 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1565 if (!ref_lock) {
1566 rollback_index_files();
1567 die(_("cannot lock HEAD ref"));
1569 if (write_ref_sha1(ref_lock, sha1, sb.buf) < 0) {
1570 rollback_index_files();
1571 die(_("cannot update HEAD ref"));
1574 unlink(git_path("CHERRY_PICK_HEAD"));
1575 unlink(git_path("REVERT_HEAD"));
1576 unlink(git_path("MERGE_HEAD"));
1577 unlink(git_path("MERGE_MSG"));
1578 unlink(git_path("MERGE_MODE"));
1579 unlink(git_path("SQUASH_MSG"));
1581 if (commit_index_files())
1582 die (_("Repository has been updated, but unable to write\n"
1583 "new_index file. Check that disk is not full or quota is\n"
1584 "not exceeded, and then \"git reset HEAD\" to recover."));
1586 rerere(0);
1587 run_hook(get_index_file(), "post-commit", NULL);
1588 if (amend && !no_post_rewrite) {
1589 struct notes_rewrite_cfg *cfg;
1590 cfg = init_copy_notes_for_rewrite("amend");
1591 if (cfg) {
1592 /* we are amending, so current_head is not NULL */
1593 copy_note_for_rewrite(cfg, current_head->object.sha1, sha1);
1594 finish_copy_notes_for_rewrite(cfg);
1596 run_rewrite_hook(current_head->object.sha1, sha1);
1598 if (!quiet)
1599 print_summary(prefix, sha1, !current_head);
1601 return 0;