![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
3714582e1988f7c286412afb779cbfefe4849657
1 /*
2 * Builtin "git commit"
3 *
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"
31 static const char * const builtin_commit_usage[] = {
32 "git commit [options] [--] <filepattern>...",
33 NULL
34 };
36 static const char * const builtin_status_usage[] = {
37 "git status [options] [--] <filepattern>...",
38 NULL
39 };
41 static const char implicit_ident_advice[] =
42 N_("Your name and email address were configured automatically based\n"
43 "on your username and hostname. Please check that they are accurate.\n"
44 "You can suppress this message by setting them explicitly:\n"
45 "\n"
46 " git config --global user.name \"Your Name\"\n"
47 " git config --global user.email you@example.com\n"
48 "\n"
49 "After doing this, you may fix the identity used for this commit with:\n"
50 "\n"
51 " git commit --amend --reset-author\n");
53 static const char empty_amend_advice[] =
54 N_("You asked to amend the most recent commit, but doing so would make\n"
55 "it empty. You can repeat your command with --allow-empty, or you can\n"
56 "remove the commit entirely with \"git reset HEAD^\".\n");
58 static const char empty_cherry_pick_advice[] =
59 N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
60 "If you wish to commit it anyway, use:\n"
61 "\n"
62 " git commit --allow-empty\n"
63 "\n"
64 "Otherwise, please use 'git reset'\n");
66 static const char *use_message_buffer;
67 static const char commit_editmsg[] = "COMMIT_EDITMSG";
68 static struct lock_file index_lock; /* real index */
69 static struct lock_file false_lock; /* used only for partial commits */
70 static enum {
71 COMMIT_AS_IS = 1,
72 COMMIT_NORMAL,
73 COMMIT_PARTIAL
74 } commit_style;
76 static const char *logfile, *force_author;
77 static const char *template_file;
78 /*
79 * The _message variables are commit names from which to take
80 * the commit message and/or authorship.
81 */
82 static const char *author_message, *author_message_buffer;
83 static char *edit_message, *use_message;
84 static char *fixup_message, *squash_message;
85 static int all, also, interactive, patch_interactive, only, amend, signoff;
86 static int edit_flag = -1; /* unspecified */
87 static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
88 static int no_post_rewrite, allow_empty_message;
89 static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
90 static char *sign_commit;
92 /*
93 * The default commit message cleanup mode will remove the lines
94 * beginning with # (shell comments) and leading and trailing
95 * whitespaces (empty lines or containing only whitespaces)
96 * if editor is used, and only the whitespaces if the message
97 * is specified explicitly.
98 */
99 static enum {
100 CLEANUP_SPACE,
101 CLEANUP_NONE,
102 CLEANUP_ALL
103 } cleanup_mode;
104 static char *cleanup_arg;
106 static enum commit_whence whence;
107 static int use_editor = 1, include_status = 1;
108 static int show_ignored_in_status;
109 static const char *only_include_assumed;
110 static struct strbuf message = STRBUF_INIT;
112 static int null_termination;
113 static enum {
114 STATUS_FORMAT_LONG,
115 STATUS_FORMAT_SHORT,
116 STATUS_FORMAT_PORCELAIN
117 } status_format = STATUS_FORMAT_LONG;
118 static int status_show_branch;
120 static int opt_parse_m(const struct option *opt, const char *arg, int unset)
121 {
122 struct strbuf *buf = opt->value;
123 if (unset)
124 strbuf_setlen(buf, 0);
125 else {
126 strbuf_addstr(buf, arg);
127 strbuf_addstr(buf, "\n\n");
128 }
129 return 0;
130 }
132 static struct option builtin_commit_options[] = {
133 OPT__QUIET(&quiet, "suppress summary after successful commit"),
134 OPT__VERBOSE(&verbose, "show diff in commit message template"),
136 OPT_GROUP("Commit message options"),
137 OPT_FILENAME('F', "file", &logfile, "read message from file"),
138 OPT_STRING(0, "author", &force_author, "author", "override author for commit"),
139 OPT_STRING(0, "date", &force_date, "date", "override date for commit"),
140 OPT_CALLBACK('m', "message", &message, "message", "commit message", opt_parse_m),
141 OPT_STRING('c', "reedit-message", &edit_message, "commit", "reuse and edit message from specified commit"),
142 OPT_STRING('C', "reuse-message", &use_message, "commit", "reuse message from specified commit"),
143 OPT_STRING(0, "fixup", &fixup_message, "commit", "use autosquash formatted message to fixup specified commit"),
144 OPT_STRING(0, "squash", &squash_message, "commit", "use autosquash formatted message to squash specified commit"),
145 OPT_BOOLEAN(0, "reset-author", &renew_authorship, "the commit is authored by me now (used with -C/-c/--amend)"),
146 OPT_BOOLEAN('s', "signoff", &signoff, "add Signed-off-by:"),
147 OPT_FILENAME('t', "template", &template_file, "use specified template file"),
148 OPT_BOOL('e', "edit", &edit_flag, "force edit of commit"),
149 OPT_STRING(0, "cleanup", &cleanup_arg, "default", "how to strip spaces and #comments from message"),
150 OPT_BOOLEAN(0, "status", &include_status, "include status in commit message template"),
151 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, "key id",
152 "GPG sign commit", PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
153 /* end commit message options */
155 OPT_GROUP("Commit contents options"),
156 OPT_BOOLEAN('a', "all", &all, "commit all changed files"),
157 OPT_BOOLEAN('i', "include", &also, "add specified files to index for commit"),
158 OPT_BOOLEAN(0, "interactive", &interactive, "interactively add files"),
159 OPT_BOOLEAN('p', "patch", &patch_interactive, "interactively add changes"),
160 OPT_BOOLEAN('o', "only", &only, "commit only specified files"),
161 OPT_BOOLEAN('n', "no-verify", &no_verify, "bypass pre-commit hook"),
162 OPT_BOOLEAN(0, "dry-run", &dry_run, "show what would be committed"),
163 OPT_SET_INT(0, "short", &status_format, "show status concisely",
164 STATUS_FORMAT_SHORT),
165 OPT_BOOLEAN(0, "branch", &status_show_branch, "show branch information"),
166 OPT_SET_INT(0, "porcelain", &status_format,
167 "machine-readable output", STATUS_FORMAT_PORCELAIN),
168 OPT_BOOLEAN('z', "null", &null_termination,
169 "terminate entries with NUL"),
170 OPT_BOOLEAN(0, "amend", &amend, "amend previous commit"),
171 OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite, "bypass post-rewrite hook"),
172 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg, "mode", "show untracked files, optional modes: all, normal, no. (Default: all)", PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
173 /* end commit contents options */
175 { OPTION_BOOLEAN, 0, "allow-empty", &allow_empty, NULL,
176 "ok to record an empty change",
177 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
178 { OPTION_BOOLEAN, 0, "allow-empty-message", &allow_empty_message, NULL,
179 "ok to record a change with an empty message",
180 PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
182 OPT_END()
183 };
185 static void determine_whence(struct wt_status *s)
186 {
187 if (file_exists(git_path("MERGE_HEAD")))
188 whence = FROM_MERGE;
189 else if (file_exists(git_path("CHERRY_PICK_HEAD")))
190 whence = FROM_CHERRY_PICK;
191 else
192 whence = FROM_COMMIT;
193 if (s)
194 s->whence = whence;
195 }
197 static const char *whence_s(void)
198 {
199 const char *s = "";
201 switch (whence) {
202 case FROM_COMMIT:
203 break;
204 case FROM_MERGE:
205 s = _("merge");
206 break;
207 case FROM_CHERRY_PICK:
208 s = _("cherry-pick");
209 break;
210 }
212 return s;
213 }
215 static void rollback_index_files(void)
216 {
217 switch (commit_style) {
218 case COMMIT_AS_IS:
219 break; /* nothing to do */
220 case COMMIT_NORMAL:
221 rollback_lock_file(&index_lock);
222 break;
223 case COMMIT_PARTIAL:
224 rollback_lock_file(&index_lock);
225 rollback_lock_file(&false_lock);
226 break;
227 }
228 }
230 static int commit_index_files(void)
231 {
232 int err = 0;
234 switch (commit_style) {
235 case COMMIT_AS_IS:
236 break; /* nothing to do */
237 case COMMIT_NORMAL:
238 err = commit_lock_file(&index_lock);
239 break;
240 case COMMIT_PARTIAL:
241 err = commit_lock_file(&index_lock);
242 rollback_lock_file(&false_lock);
243 break;
244 }
246 return err;
247 }
249 /*
250 * Take a union of paths in the index and the named tree (typically, "HEAD"),
251 * and return the paths that match the given pattern in list.
252 */
253 static int list_paths(struct string_list *list, const char *with_tree,
254 const char *prefix, const char **pattern)
255 {
256 int i;
257 char *m;
259 for (i = 0; pattern[i]; i++)
260 ;
261 m = xcalloc(1, i);
263 if (with_tree) {
264 char *max_prefix = common_prefix(pattern);
265 overlay_tree_on_cache(with_tree, max_prefix ? max_prefix : prefix);
266 free(max_prefix);
267 }
269 for (i = 0; i < active_nr; i++) {
270 struct cache_entry *ce = active_cache[i];
271 struct string_list_item *item;
273 if (ce->ce_flags & CE_UPDATE)
274 continue;
275 if (!match_pathspec(pattern, ce->name, ce_namelen(ce), 0, m))
276 continue;
277 item = string_list_insert(list, ce->name);
278 if (ce_skip_worktree(ce))
279 item->util = item; /* better a valid pointer than a fake one */
280 }
282 return report_path_error(m, pattern, prefix);
283 }
285 static void add_remove_files(struct string_list *list)
286 {
287 int i;
288 for (i = 0; i < list->nr; i++) {
289 struct stat st;
290 struct string_list_item *p = &(list->items[i]);
292 /* p->util is skip-worktree */
293 if (p->util)
294 continue;
296 if (!lstat(p->string, &st)) {
297 if (add_to_cache(p->string, &st, 0))
298 die(_("updating files failed"));
299 } else
300 remove_file_from_cache(p->string);
301 }
302 }
304 static void create_base_index(const struct commit *current_head)
305 {
306 struct tree *tree;
307 struct unpack_trees_options opts;
308 struct tree_desc t;
310 if (!current_head) {
311 discard_cache();
312 return;
313 }
315 memset(&opts, 0, sizeof(opts));
316 opts.head_idx = 1;
317 opts.index_only = 1;
318 opts.merge = 1;
319 opts.src_index = &the_index;
320 opts.dst_index = &the_index;
322 opts.fn = oneway_merge;
323 tree = parse_tree_indirect(current_head->object.sha1);
324 if (!tree)
325 die(_("failed to unpack HEAD tree object"));
326 parse_tree(tree);
327 init_tree_desc(&t, tree->buffer, tree->size);
328 if (unpack_trees(1, &t, &opts))
329 exit(128); /* We've already reported the error, finish dying */
330 }
332 static void refresh_cache_or_die(int refresh_flags)
333 {
334 /*
335 * refresh_flags contains REFRESH_QUIET, so the only errors
336 * are for unmerged entries.
337 */
338 if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
339 die_resolve_conflict("commit");
340 }
342 static char *prepare_index(int argc, const char **argv, const char *prefix,
343 const struct commit *current_head, int is_status)
344 {
345 int fd;
346 struct string_list partial;
347 const char **pathspec = NULL;
348 char *old_index_env = NULL;
349 int refresh_flags = REFRESH_QUIET;
351 if (is_status)
352 refresh_flags |= REFRESH_UNMERGED;
354 if (*argv)
355 pathspec = get_pathspec(prefix, argv);
357 if (read_cache_preload(pathspec) < 0)
358 die(_("index file corrupt"));
360 if (interactive) {
361 fd = hold_locked_index(&index_lock, 1);
363 refresh_cache_or_die(refresh_flags);
365 if (write_cache(fd, active_cache, active_nr) ||
366 close_lock_file(&index_lock))
367 die(_("unable to create temporary index"));
369 old_index_env = getenv(INDEX_ENVIRONMENT);
370 setenv(INDEX_ENVIRONMENT, index_lock.filename, 1);
372 if (interactive_add(argc, argv, prefix, patch_interactive) != 0)
373 die(_("interactive add failed"));
375 if (old_index_env && *old_index_env)
376 setenv(INDEX_ENVIRONMENT, old_index_env, 1);
377 else
378 unsetenv(INDEX_ENVIRONMENT);
380 discard_cache();
381 read_cache_from(index_lock.filename);
383 commit_style = COMMIT_NORMAL;
384 return index_lock.filename;
385 }
387 /*
388 * Non partial, non as-is commit.
389 *
390 * (1) get the real index;
391 * (2) update the_index as necessary;
392 * (3) write the_index out to the real index (still locked);
393 * (4) return the name of the locked index file.
394 *
395 * The caller should run hooks on the locked real index, and
396 * (A) if all goes well, commit the real index;
397 * (B) on failure, rollback the real index.
398 */
399 if (all || (also && pathspec && *pathspec)) {
400 fd = hold_locked_index(&index_lock, 1);
401 add_files_to_cache(also ? prefix : NULL, pathspec, 0);
402 refresh_cache_or_die(refresh_flags);
403 update_main_cache_tree(WRITE_TREE_SILENT);
404 if (write_cache(fd, active_cache, active_nr) ||
405 close_lock_file(&index_lock))
406 die(_("unable to write new_index file"));
407 commit_style = COMMIT_NORMAL;
408 return index_lock.filename;
409 }
411 /*
412 * As-is commit.
413 *
414 * (1) return the name of the real index file.
415 *
416 * The caller should run hooks on the real index,
417 * and create commit from the_index.
418 * We still need to refresh the index here.
419 */
420 if (!pathspec || !*pathspec) {
421 fd = hold_locked_index(&index_lock, 1);
422 refresh_cache_or_die(refresh_flags);
423 if (active_cache_changed) {
424 update_main_cache_tree(WRITE_TREE_SILENT);
425 if (write_cache(fd, active_cache, active_nr) ||
426 commit_locked_index(&index_lock))
427 die(_("unable to write new_index file"));
428 } else {
429 rollback_lock_file(&index_lock);
430 }
431 commit_style = COMMIT_AS_IS;
432 return get_index_file();
433 }
435 /*
436 * A partial commit.
437 *
438 * (0) find the set of affected paths;
439 * (1) get lock on the real index file;
440 * (2) update the_index with the given paths;
441 * (3) write the_index out to the real index (still locked);
442 * (4) get lock on the false index file;
443 * (5) reset the_index from HEAD;
444 * (6) update the_index the same way as (2);
445 * (7) write the_index out to the false index file;
446 * (8) return the name of the false index file (still locked);
447 *
448 * The caller should run hooks on the locked false index, and
449 * create commit from it. Then
450 * (A) if all goes well, commit the real index;
451 * (B) on failure, rollback the real index;
452 * In either case, rollback the false index.
453 */
454 commit_style = COMMIT_PARTIAL;
456 if (whence != FROM_COMMIT)
457 die(_("cannot do a partial commit during a %s."), whence_s());
459 memset(&partial, 0, sizeof(partial));
460 partial.strdup_strings = 1;
461 if (list_paths(&partial, !current_head ? NULL : "HEAD", prefix, pathspec))
462 exit(1);
464 discard_cache();
465 if (read_cache() < 0)
466 die(_("cannot read the index"));
468 fd = hold_locked_index(&index_lock, 1);
469 add_remove_files(&partial);
470 refresh_cache(REFRESH_QUIET);
471 if (write_cache(fd, active_cache, active_nr) ||
472 close_lock_file(&index_lock))
473 die(_("unable to write new_index file"));
475 fd = hold_lock_file_for_update(&false_lock,
476 git_path("next-index-%"PRIuMAX,
477 (uintmax_t) getpid()),
478 LOCK_DIE_ON_ERROR);
480 create_base_index(current_head);
481 add_remove_files(&partial);
482 refresh_cache(REFRESH_QUIET);
484 if (write_cache(fd, active_cache, active_nr) ||
485 close_lock_file(&false_lock))
486 die(_("unable to write temporary index file"));
488 discard_cache();
489 read_cache_from(false_lock.filename);
491 return false_lock.filename;
492 }
494 static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
495 struct wt_status *s)
496 {
497 unsigned char sha1[20];
499 if (s->relative_paths)
500 s->prefix = prefix;
502 if (amend) {
503 s->amend = 1;
504 s->reference = "HEAD^1";
505 }
506 s->verbose = verbose;
507 s->index_file = index_file;
508 s->fp = fp;
509 s->nowarn = nowarn;
510 s->is_initial = get_sha1(s->reference, sha1) ? 1 : 0;
512 wt_status_collect(s);
514 switch (status_format) {
515 case STATUS_FORMAT_SHORT:
516 wt_shortstatus_print(s, null_termination, status_show_branch);
517 break;
518 case STATUS_FORMAT_PORCELAIN:
519 wt_porcelain_print(s, null_termination);
520 break;
521 case STATUS_FORMAT_LONG:
522 wt_status_print(s);
523 break;
524 }
526 return s->commitable;
527 }
529 static int is_a_merge(const struct commit *current_head)
530 {
531 return !!(current_head->parents && current_head->parents->next);
532 }
534 static const char sign_off_header[] = "Signed-off-by: ";
536 static void determine_author_info(struct strbuf *author_ident)
537 {
538 char *name, *email, *date;
540 name = getenv("GIT_AUTHOR_NAME");
541 email = getenv("GIT_AUTHOR_EMAIL");
542 date = getenv("GIT_AUTHOR_DATE");
544 if (author_message) {
545 const char *a, *lb, *rb, *eol;
546 size_t len;
548 a = strstr(author_message_buffer, "\nauthor ");
549 if (!a)
550 die(_("invalid commit: %s"), author_message);
552 lb = strchrnul(a + strlen("\nauthor "), '<');
553 rb = strchrnul(lb, '>');
554 eol = strchrnul(rb, '\n');
555 if (!*lb || !*rb || !*eol)
556 die(_("invalid commit: %s"), author_message);
558 if (lb == a + strlen("\nauthor "))
559 /* \nauthor <foo@example.com> */
560 name = xcalloc(1, 1);
561 else
562 name = xmemdupz(a + strlen("\nauthor "),
563 (lb - strlen(" ") -
564 (a + strlen("\nauthor "))));
565 email = xmemdupz(lb + strlen("<"), rb - (lb + strlen("<")));
566 date = xmemdupz(rb + strlen("> "), eol - (rb + strlen("> ")));
567 len = eol - (rb + strlen("> "));
568 date = xmalloc(len + 2);
569 *date = '@';
570 memcpy(date + 1, rb + strlen("> "), len);
571 date[len + 1] = '\0';
572 }
574 if (force_author) {
575 const char *lb = strstr(force_author, " <");
576 const char *rb = strchr(force_author, '>');
578 if (!lb || !rb)
579 die(_("malformed --author parameter"));
580 name = xstrndup(force_author, lb - force_author);
581 email = xstrndup(lb + 2, rb - (lb + 2));
582 }
584 if (force_date)
585 date = force_date;
586 strbuf_addstr(author_ident, fmt_ident(name, email, date,
587 IDENT_ERROR_ON_NO_NAME));
588 }
590 static int ends_rfc2822_footer(struct strbuf *sb)
591 {
592 int ch;
593 int hit = 0;
594 int i, j, k;
595 int len = sb->len;
596 int first = 1;
597 const char *buf = sb->buf;
599 for (i = len - 1; i > 0; i--) {
600 if (hit && buf[i] == '\n')
601 break;
602 hit = (buf[i] == '\n');
603 }
605 while (i < len - 1 && buf[i] == '\n')
606 i++;
608 for (; i < len; i = k) {
609 for (k = i; k < len && buf[k] != '\n'; k++)
610 ; /* do nothing */
611 k++;
613 if ((buf[k] == ' ' || buf[k] == '\t') && !first)
614 continue;
616 first = 0;
618 for (j = 0; i + j < len; j++) {
619 ch = buf[i + j];
620 if (ch == ':')
621 break;
622 if (isalnum(ch) ||
623 (ch == '-'))
624 continue;
625 return 0;
626 }
627 }
628 return 1;
629 }
631 static char *cut_ident_timestamp_part(char *string)
632 {
633 char *ket = strrchr(string, '>');
634 if (!ket || ket[1] != ' ')
635 die(_("Malformed ident string: '%s'"), string);
636 *++ket = '\0';
637 return ket;
638 }
640 static int prepare_to_commit(const char *index_file, const char *prefix,
641 struct commit *current_head,
642 struct wt_status *s,
643 struct strbuf *author_ident)
644 {
645 struct stat statbuf;
646 struct strbuf committer_ident = STRBUF_INIT;
647 int commitable, saved_color_setting;
648 struct strbuf sb = STRBUF_INIT;
649 char *buffer;
650 const char *hook_arg1 = NULL;
651 const char *hook_arg2 = NULL;
652 int ident_shown = 0;
653 int clean_message_contents = (cleanup_mode != CLEANUP_NONE);
655 if (!no_verify && run_hook(index_file, "pre-commit", NULL))
656 return 0;
658 if (squash_message) {
659 /*
660 * Insert the proper subject line before other commit
661 * message options add their content.
662 */
663 if (use_message && !strcmp(use_message, squash_message))
664 strbuf_addstr(&sb, "squash! ");
665 else {
666 struct pretty_print_context ctx = {0};
667 struct commit *c;
668 c = lookup_commit_reference_by_name(squash_message);
669 if (!c)
670 die(_("could not lookup commit %s"), squash_message);
671 ctx.output_encoding = get_commit_output_encoding();
672 format_commit_message(c, "squash! %s\n\n", &sb,
673 &ctx);
674 }
675 }
677 if (message.len) {
678 strbuf_addbuf(&sb, &message);
679 hook_arg1 = "message";
680 } else if (logfile && !strcmp(logfile, "-")) {
681 if (isatty(0))
682 fprintf(stderr, _("(reading log message from standard input)\n"));
683 if (strbuf_read(&sb, 0, 0) < 0)
684 die_errno(_("could not read log from standard input"));
685 hook_arg1 = "message";
686 } else if (logfile) {
687 if (strbuf_read_file(&sb, logfile, 0) < 0)
688 die_errno(_("could not read log file '%s'"),
689 logfile);
690 hook_arg1 = "message";
691 } else if (use_message) {
692 buffer = strstr(use_message_buffer, "\n\n");
693 if (!buffer || buffer[2] == '\0')
694 die(_("commit has empty message"));
695 strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
696 hook_arg1 = "commit";
697 hook_arg2 = use_message;
698 } else if (fixup_message) {
699 struct pretty_print_context ctx = {0};
700 struct commit *commit;
701 commit = lookup_commit_reference_by_name(fixup_message);
702 if (!commit)
703 die(_("could not lookup commit %s"), fixup_message);
704 ctx.output_encoding = get_commit_output_encoding();
705 format_commit_message(commit, "fixup! %s\n\n",
706 &sb, &ctx);
707 hook_arg1 = "message";
708 } else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
709 if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
710 die_errno(_("could not read MERGE_MSG"));
711 hook_arg1 = "merge";
712 } else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
713 if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
714 die_errno(_("could not read SQUASH_MSG"));
715 hook_arg1 = "squash";
716 } else if (template_file) {
717 if (strbuf_read_file(&sb, template_file, 0) < 0)
718 die_errno(_("could not read '%s'"), template_file);
719 hook_arg1 = "template";
720 clean_message_contents = 0;
721 }
723 /*
724 * The remaining cases don't modify the template message, but
725 * just set the argument(s) to the prepare-commit-msg hook.
726 */
727 else if (whence == FROM_MERGE)
728 hook_arg1 = "merge";
729 else if (whence == FROM_CHERRY_PICK) {
730 hook_arg1 = "commit";
731 hook_arg2 = "CHERRY_PICK_HEAD";
732 }
734 if (squash_message) {
735 /*
736 * If squash_commit was used for the commit subject,
737 * then we're possibly hijacking other commit log options.
738 * Reset the hook args to tell the real story.
739 */
740 hook_arg1 = "message";
741 hook_arg2 = "";
742 }
744 s->fp = fopen(git_path(commit_editmsg), "w");
745 if (s->fp == NULL)
746 die_errno(_("could not open '%s'"), git_path(commit_editmsg));
748 if (clean_message_contents)
749 stripspace(&sb, 0);
751 if (signoff) {
752 struct strbuf sob = STRBUF_INIT;
753 int i;
755 strbuf_addstr(&sob, sign_off_header);
756 strbuf_addstr(&sob, fmt_name(getenv("GIT_COMMITTER_NAME"),
757 getenv("GIT_COMMITTER_EMAIL")));
758 strbuf_addch(&sob, '\n');
759 for (i = sb.len - 1; i > 0 && sb.buf[i - 1] != '\n'; i--)
760 ; /* do nothing */
761 if (prefixcmp(sb.buf + i, sob.buf)) {
762 if (!i || !ends_rfc2822_footer(&sb))
763 strbuf_addch(&sb, '\n');
764 strbuf_addbuf(&sb, &sob);
765 }
766 strbuf_release(&sob);
767 }
769 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
770 die_errno(_("could not write commit template"));
772 strbuf_release(&sb);
774 /* This checks and barfs if author is badly specified */
775 determine_author_info(author_ident);
777 /* This checks if committer ident is explicitly given */
778 strbuf_addstr(&committer_ident, git_committer_info(0));
779 if (use_editor && include_status) {
780 char *ai_tmp, *ci_tmp;
781 if (whence != FROM_COMMIT)
782 status_printf_ln(s, GIT_COLOR_NORMAL,
783 _("\n"
784 "It looks like you may be committing a %s.\n"
785 "If this is not correct, please remove the file\n"
786 " %s\n"
787 "and try again.\n"
788 ""),
789 whence_s(),
790 git_path(whence == FROM_MERGE
791 ? "MERGE_HEAD"
792 : "CHERRY_PICK_HEAD"));
794 fprintf(s->fp, "\n");
795 status_printf(s, GIT_COLOR_NORMAL,
796 _("Please enter the commit message for your changes."));
797 if (cleanup_mode == CLEANUP_ALL)
798 status_printf_more(s, GIT_COLOR_NORMAL,
799 _(" Lines starting\n"
800 "with '#' will be ignored, and an empty"
801 " message aborts the commit.\n"));
802 else /* CLEANUP_SPACE, that is. */
803 status_printf_more(s, GIT_COLOR_NORMAL,
804 _(" Lines starting\n"
805 "with '#' will be kept; you may remove them"
806 " yourself if you want to.\n"
807 "An empty message aborts the commit.\n"));
808 if (only_include_assumed)
809 status_printf_ln(s, GIT_COLOR_NORMAL,
810 "%s", only_include_assumed);
812 ai_tmp = cut_ident_timestamp_part(author_ident->buf);
813 ci_tmp = cut_ident_timestamp_part(committer_ident.buf);
814 if (strcmp(author_ident->buf, committer_ident.buf))
815 status_printf_ln(s, GIT_COLOR_NORMAL,
816 _("%s"
817 "Author: %s"),
818 ident_shown++ ? "" : "\n",
819 author_ident->buf);
821 if (!user_ident_sufficiently_given())
822 status_printf_ln(s, GIT_COLOR_NORMAL,
823 _("%s"
824 "Committer: %s"),
825 ident_shown++ ? "" : "\n",
826 committer_ident.buf);
828 if (ident_shown)
829 status_printf_ln(s, GIT_COLOR_NORMAL, "");
831 saved_color_setting = s->use_color;
832 s->use_color = 0;
833 commitable = run_status(s->fp, index_file, prefix, 1, s);
834 s->use_color = saved_color_setting;
836 *ai_tmp = ' ';
837 *ci_tmp = ' ';
838 } else {
839 unsigned char sha1[20];
840 const char *parent = "HEAD";
842 if (!active_nr && read_cache() < 0)
843 die(_("Cannot read index"));
845 if (amend)
846 parent = "HEAD^1";
848 if (get_sha1(parent, sha1))
849 commitable = !!active_nr;
850 else
851 commitable = index_differs_from(parent, 0);
852 }
853 strbuf_release(&committer_ident);
855 fclose(s->fp);
857 /*
858 * Reject an attempt to record a non-merge empty commit without
859 * explicit --allow-empty. In the cherry-pick case, it may be
860 * empty due to conflict resolution, which the user should okay.
861 */
862 if (!commitable && whence != FROM_MERGE && !allow_empty &&
863 !(amend && is_a_merge(current_head))) {
864 run_status(stdout, index_file, prefix, 0, s);
865 if (amend)
866 fputs(_(empty_amend_advice), stderr);
867 else if (whence == FROM_CHERRY_PICK)
868 fputs(_(empty_cherry_pick_advice), stderr);
869 return 0;
870 }
872 /*
873 * Re-read the index as pre-commit hook could have updated it,
874 * and write it out as a tree. We must do this before we invoke
875 * the editor and after we invoke run_status above.
876 */
877 discard_cache();
878 read_cache_from(index_file);
879 if (update_main_cache_tree(0)) {
880 error(_("Error building trees"));
881 return 0;
882 }
884 if (run_hook(index_file, "prepare-commit-msg",
885 git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
886 return 0;
888 if (use_editor) {
889 char index[PATH_MAX];
890 const char *env[2] = { NULL };
891 env[0] = index;
892 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
893 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
894 fprintf(stderr,
895 _("Please supply the message using either -m or -F option.\n"));
896 exit(1);
897 }
898 }
900 if (!no_verify &&
901 run_hook(index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
902 return 0;
903 }
905 return 1;
906 }
908 /*
909 * Find out if the message in the strbuf contains only whitespace and
910 * Signed-off-by lines.
911 */
912 static int message_is_empty(struct strbuf *sb)
913 {
914 struct strbuf tmpl = STRBUF_INIT;
915 const char *nl;
916 int eol, i, start = 0;
918 if (cleanup_mode == CLEANUP_NONE && sb->len)
919 return 0;
921 /* See if the template is just a prefix of the message. */
922 if (template_file && strbuf_read_file(&tmpl, template_file, 0) > 0) {
923 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
924 if (start + tmpl.len <= sb->len &&
925 memcmp(tmpl.buf, sb->buf + start, tmpl.len) == 0)
926 start += tmpl.len;
927 }
928 strbuf_release(&tmpl);
930 /* Check if the rest is just whitespace and Signed-of-by's. */
931 for (i = start; i < sb->len; i++) {
932 nl = memchr(sb->buf + i, '\n', sb->len - i);
933 if (nl)
934 eol = nl - sb->buf;
935 else
936 eol = sb->len;
938 if (strlen(sign_off_header) <= eol - i &&
939 !prefixcmp(sb->buf + i, sign_off_header)) {
940 i = eol;
941 continue;
942 }
943 while (i < eol)
944 if (!isspace(sb->buf[i++]))
945 return 0;
946 }
948 return 1;
949 }
951 static const char *find_author_by_nickname(const char *name)
952 {
953 struct rev_info revs;
954 struct commit *commit;
955 struct strbuf buf = STRBUF_INIT;
956 const char *av[20];
957 int ac = 0;
959 init_revisions(&revs, NULL);
960 strbuf_addf(&buf, "--author=%s", name);
961 av[++ac] = "--all";
962 av[++ac] = "-i";
963 av[++ac] = buf.buf;
964 av[++ac] = NULL;
965 setup_revisions(ac, av, &revs, NULL);
966 prepare_revision_walk(&revs);
967 commit = get_revision(&revs);
968 if (commit) {
969 struct pretty_print_context ctx = {0};
970 ctx.date_mode = DATE_NORMAL;
971 strbuf_release(&buf);
972 format_commit_message(commit, "%an <%ae>", &buf, &ctx);
973 return strbuf_detach(&buf, NULL);
974 }
975 die(_("No existing author found with '%s'"), name);
976 }
979 static void handle_untracked_files_arg(struct wt_status *s)
980 {
981 if (!untracked_files_arg)
982 ; /* default already initialized */
983 else if (!strcmp(untracked_files_arg, "no"))
984 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
985 else if (!strcmp(untracked_files_arg, "normal"))
986 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
987 else if (!strcmp(untracked_files_arg, "all"))
988 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
989 else
990 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
991 }
993 static const char *read_commit_message(const char *name)
994 {
995 const char *out_enc, *out;
996 struct commit *commit;
998 commit = lookup_commit_reference_by_name(name);
999 if (!commit)
1000 die(_("could not lookup commit %s"), name);
1001 out_enc = get_commit_output_encoding();
1002 out = logmsg_reencode(commit, out_enc);
1004 /*
1005 * If we failed to reencode the buffer, just copy it
1006 * byte for byte so the user can try to fix it up.
1007 * This also handles the case where input and output
1008 * encodings are identical.
1009 */
1010 if (out == NULL)
1011 out = xstrdup(commit->buffer);
1012 return out;
1013 }
1015 static int parse_and_validate_options(int argc, const char *argv[],
1016 const char * const usage[],
1017 const char *prefix,
1018 struct commit *current_head,
1019 struct wt_status *s)
1020 {
1021 int f = 0;
1023 argc = parse_options(argc, argv, prefix, builtin_commit_options, usage,
1024 0);
1026 if (force_author && !strchr(force_author, '>'))
1027 force_author = find_author_by_nickname(force_author);
1029 if (force_author && renew_authorship)
1030 die(_("Using both --reset-author and --author does not make sense"));
1032 if (logfile || message.len || use_message || fixup_message)
1033 use_editor = 0;
1034 if (0 <= edit_flag)
1035 use_editor = edit_flag;
1036 if (!use_editor)
1037 setenv("GIT_EDITOR", ":", 1);
1039 /* Sanity check options */
1040 if (amend && !current_head)
1041 die(_("You have nothing to amend."));
1042 if (amend && whence != FROM_COMMIT)
1043 die(_("You are in the middle of a %s -- cannot amend."), whence_s());
1044 if (fixup_message && squash_message)
1045 die(_("Options --squash and --fixup cannot be used together"));
1046 if (use_message)
1047 f++;
1048 if (edit_message)
1049 f++;
1050 if (fixup_message)
1051 f++;
1052 if (logfile)
1053 f++;
1054 if (f > 1)
1055 die(_("Only one of -c/-C/-F/--fixup can be used."));
1056 if (message.len && f > 0)
1057 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1058 if (edit_message)
1059 use_message = edit_message;
1060 if (amend && !use_message && !fixup_message)
1061 use_message = "HEAD";
1062 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
1063 die(_("--reset-author can be used only with -C, -c or --amend."));
1064 if (use_message) {
1065 use_message_buffer = read_commit_message(use_message);
1066 if (!renew_authorship) {
1067 author_message = use_message;
1068 author_message_buffer = use_message_buffer;
1069 }
1070 }
1071 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1072 author_message = "CHERRY_PICK_HEAD";
1073 author_message_buffer = read_commit_message(author_message);
1074 }
1076 if (patch_interactive)
1077 interactive = 1;
1079 if (!!also + !!only + !!all + !!interactive > 1)
1080 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1081 if (argc == 0 && (also || (only && !amend)))
1082 die(_("No paths with --include/--only does not make sense."));
1083 if (argc == 0 && only && amend)
1084 only_include_assumed = _("Clever... amending the last one with dirty index.");
1085 if (argc > 0 && !also && !only)
1086 only_include_assumed = _("Explicit paths specified without -i nor -o; assuming --only paths...");
1087 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1088 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1089 else if (!strcmp(cleanup_arg, "verbatim"))
1090 cleanup_mode = CLEANUP_NONE;
1091 else if (!strcmp(cleanup_arg, "whitespace"))
1092 cleanup_mode = CLEANUP_SPACE;
1093 else if (!strcmp(cleanup_arg, "strip"))
1094 cleanup_mode = CLEANUP_ALL;
1095 else
1096 die(_("Invalid cleanup mode %s"), cleanup_arg);
1098 handle_untracked_files_arg(s);
1100 if (all && argc > 0)
1101 die(_("Paths with -a does not make sense."));
1103 if (null_termination && status_format == STATUS_FORMAT_LONG)
1104 status_format = STATUS_FORMAT_PORCELAIN;
1105 if (status_format != STATUS_FORMAT_LONG)
1106 dry_run = 1;
1108 return argc;
1109 }
1111 static int dry_run_commit(int argc, const char **argv, const char *prefix,
1112 const struct commit *current_head, struct wt_status *s)
1113 {
1114 int commitable;
1115 const char *index_file;
1117 index_file = prepare_index(argc, argv, prefix, current_head, 1);
1118 commitable = run_status(stdout, index_file, prefix, 0, s);
1119 rollback_index_files();
1121 return commitable ? 0 : 1;
1122 }
1124 static int parse_status_slot(const char *var, int offset)
1125 {
1126 if (!strcasecmp(var+offset, "header"))
1127 return WT_STATUS_HEADER;
1128 if (!strcasecmp(var+offset, "branch"))
1129 return WT_STATUS_ONBRANCH;
1130 if (!strcasecmp(var+offset, "updated")
1131 || !strcasecmp(var+offset, "added"))
1132 return WT_STATUS_UPDATED;
1133 if (!strcasecmp(var+offset, "changed"))
1134 return WT_STATUS_CHANGED;
1135 if (!strcasecmp(var+offset, "untracked"))
1136 return WT_STATUS_UNTRACKED;
1137 if (!strcasecmp(var+offset, "nobranch"))
1138 return WT_STATUS_NOBRANCH;
1139 if (!strcasecmp(var+offset, "unmerged"))
1140 return WT_STATUS_UNMERGED;
1141 return -1;
1142 }
1144 static int git_status_config(const char *k, const char *v, void *cb)
1145 {
1146 struct wt_status *s = cb;
1148 if (!strcmp(k, "status.submodulesummary")) {
1149 int is_bool;
1150 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1151 if (is_bool && s->submodule_summary)
1152 s->submodule_summary = -1;
1153 return 0;
1154 }
1155 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1156 s->use_color = git_config_colorbool(k, v);
1157 return 0;
1158 }
1159 if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
1160 int slot = parse_status_slot(k, 13);
1161 if (slot < 0)
1162 return 0;
1163 if (!v)
1164 return config_error_nonbool(k);
1165 color_parse(v, k, s->color_palette[slot]);
1166 return 0;
1167 }
1168 if (!strcmp(k, "status.relativepaths")) {
1169 s->relative_paths = git_config_bool(k, v);
1170 return 0;
1171 }
1172 if (!strcmp(k, "status.showuntrackedfiles")) {
1173 if (!v)
1174 return config_error_nonbool(k);
1175 else if (!strcmp(v, "no"))
1176 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1177 else if (!strcmp(v, "normal"))
1178 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1179 else if (!strcmp(v, "all"))
1180 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1181 else
1182 return error(_("Invalid untracked files mode '%s'"), v);
1183 return 0;
1184 }
1185 return git_diff_ui_config(k, v, NULL);
1186 }
1188 int cmd_status(int argc, const char **argv, const char *prefix)
1189 {
1190 struct wt_status s;
1191 int fd;
1192 unsigned char sha1[20];
1193 static struct option builtin_status_options[] = {
1194 OPT__VERBOSE(&verbose, "be verbose"),
1195 OPT_SET_INT('s', "short", &status_format,
1196 "show status concisely", STATUS_FORMAT_SHORT),
1197 OPT_BOOLEAN('b', "branch", &status_show_branch,
1198 "show branch information"),
1199 OPT_SET_INT(0, "porcelain", &status_format,
1200 "machine-readable output",
1201 STATUS_FORMAT_PORCELAIN),
1202 OPT_BOOLEAN('z', "null", &null_termination,
1203 "terminate entries with NUL"),
1204 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1205 "mode",
1206 "show untracked files, optional modes: all, normal, no. (Default: all)",
1207 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1208 OPT_BOOLEAN(0, "ignored", &show_ignored_in_status,
1209 "show ignored files"),
1210 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, "when",
1211 "ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)",
1212 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
1213 OPT_END(),
1214 };
1216 if (argc == 2 && !strcmp(argv[1], "-h"))
1217 usage_with_options(builtin_status_usage, builtin_status_options);
1219 wt_status_prepare(&s);
1220 gitmodules_config();
1221 git_config(git_status_config, &s);
1222 determine_whence(&s);
1223 argc = parse_options(argc, argv, prefix,
1224 builtin_status_options,
1225 builtin_status_usage, 0);
1227 if (null_termination && status_format == STATUS_FORMAT_LONG)
1228 status_format = STATUS_FORMAT_PORCELAIN;
1230 handle_untracked_files_arg(&s);
1231 if (show_ignored_in_status)
1232 s.show_ignored_files = 1;
1233 if (*argv)
1234 s.pathspec = get_pathspec(prefix, argv);
1236 read_cache_preload(s.pathspec);
1237 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);
1239 fd = hold_locked_index(&index_lock, 0);
1240 if (0 <= fd)
1241 update_index_if_able(&the_index, &index_lock);
1243 s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1244 s.ignore_submodule_arg = ignore_submodule_arg;
1245 wt_status_collect(&s);
1247 if (s.relative_paths)
1248 s.prefix = prefix;
1250 switch (status_format) {
1251 case STATUS_FORMAT_SHORT:
1252 wt_shortstatus_print(&s, null_termination, status_show_branch);
1253 break;
1254 case STATUS_FORMAT_PORCELAIN:
1255 wt_porcelain_print(&s, null_termination);
1256 break;
1257 case STATUS_FORMAT_LONG:
1258 s.verbose = verbose;
1259 s.ignore_submodule_arg = ignore_submodule_arg;
1260 wt_status_print(&s);
1261 break;
1262 }
1263 return 0;
1264 }
1266 static void print_summary(const char *prefix, const unsigned char *sha1,
1267 int initial_commit)
1268 {
1269 struct rev_info rev;
1270 struct commit *commit;
1271 struct strbuf format = STRBUF_INIT;
1272 unsigned char junk_sha1[20];
1273 const char *head;
1274 struct pretty_print_context pctx = {0};
1275 struct strbuf author_ident = STRBUF_INIT;
1276 struct strbuf committer_ident = STRBUF_INIT;
1278 commit = lookup_commit(sha1);
1279 if (!commit)
1280 die(_("couldn't look up newly created commit"));
1281 if (!commit || parse_commit(commit))
1282 die(_("could not parse newly created commit"));
1284 strbuf_addstr(&format, "format:%h] %s");
1286 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1287 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1288 if (strbuf_cmp(&author_ident, &committer_ident)) {
1289 strbuf_addstr(&format, "\n Author: ");
1290 strbuf_addbuf_percentquote(&format, &author_ident);
1291 }
1292 if (!user_ident_sufficiently_given()) {
1293 strbuf_addstr(&format, "\n Committer: ");
1294 strbuf_addbuf_percentquote(&format, &committer_ident);
1295 if (advice_implicit_identity) {
1296 strbuf_addch(&format, '\n');
1297 strbuf_addstr(&format, _(implicit_ident_advice));
1298 }
1299 }
1300 strbuf_release(&author_ident);
1301 strbuf_release(&committer_ident);
1303 init_revisions(&rev, prefix);
1304 setup_revisions(0, NULL, &rev, NULL);
1306 rev.diff = 1;
1307 rev.diffopt.output_format =
1308 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1310 rev.verbose_header = 1;
1311 rev.show_root_diff = 1;
1312 get_commit_format(format.buf, &rev);
1313 rev.always_show_header = 0;
1314 rev.diffopt.detect_rename = 1;
1315 rev.diffopt.break_opt = 0;
1316 diff_setup_done(&rev.diffopt);
1318 head = resolve_ref_unsafe("HEAD", junk_sha1, 0, NULL);
1319 printf("[%s%s ",
1320 !prefixcmp(head, "refs/heads/") ?
1321 head + 11 :
1322 !strcmp(head, "HEAD") ?
1323 _("detached HEAD") :
1324 head,
1325 initial_commit ? _(" (root-commit)") : "");
1327 if (!log_tree_commit(&rev, commit)) {
1328 rev.always_show_header = 1;
1329 rev.use_terminator = 1;
1330 log_tree_commit(&rev, commit);
1331 }
1333 strbuf_release(&format);
1334 }
1336 static int git_commit_config(const char *k, const char *v, void *cb)
1337 {
1338 struct wt_status *s = cb;
1339 int status;
1341 if (!strcmp(k, "commit.template"))
1342 return git_config_pathname(&template_file, k, v);
1343 if (!strcmp(k, "commit.status")) {
1344 include_status = git_config_bool(k, v);
1345 return 0;
1346 }
1348 status = git_gpg_config(k, v, NULL);
1349 if (status)
1350 return status;
1351 return git_status_config(k, v, s);
1352 }
1354 static const char post_rewrite_hook[] = "hooks/post-rewrite";
1356 static int run_rewrite_hook(const unsigned char *oldsha1,
1357 const unsigned char *newsha1)
1358 {
1359 /* oldsha1 SP newsha1 LF NUL */
1360 static char buf[2*40 + 3];
1361 struct child_process proc;
1362 const char *argv[3];
1363 int code;
1364 size_t n;
1366 if (access(git_path(post_rewrite_hook), X_OK) < 0)
1367 return 0;
1369 argv[0] = git_path(post_rewrite_hook);
1370 argv[1] = "amend";
1371 argv[2] = NULL;
1373 memset(&proc, 0, sizeof(proc));
1374 proc.argv = argv;
1375 proc.in = -1;
1376 proc.stdout_to_stderr = 1;
1378 code = start_command(&proc);
1379 if (code)
1380 return code;
1381 n = snprintf(buf, sizeof(buf), "%s %s\n",
1382 sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1383 write_in_full(proc.in, buf, n);
1384 close(proc.in);
1385 return finish_command(&proc);
1386 }
1388 int cmd_commit(int argc, const char **argv, const char *prefix)
1389 {
1390 struct strbuf sb = STRBUF_INIT;
1391 struct strbuf author_ident = STRBUF_INIT;
1392 const char *index_file, *reflog_msg;
1393 char *nl, *p;
1394 unsigned char sha1[20];
1395 struct ref_lock *ref_lock;
1396 struct commit_list *parents = NULL, **pptr = &parents;
1397 struct stat statbuf;
1398 int allow_fast_forward = 1;
1399 struct wt_status s;
1400 struct commit *current_head = NULL;
1401 struct commit_extra_header *extra = NULL;
1403 if (argc == 2 && !strcmp(argv[1], "-h"))
1404 usage_with_options(builtin_commit_usage, builtin_commit_options);
1406 wt_status_prepare(&s);
1407 git_config(git_commit_config, &s);
1408 determine_whence(&s);
1410 if (get_sha1("HEAD", sha1))
1411 current_head = NULL;
1412 else {
1413 current_head = lookup_commit_or_die(sha1, "HEAD");
1414 if (!current_head || parse_commit(current_head))
1415 die(_("could not parse HEAD commit"));
1416 }
1417 argc = parse_and_validate_options(argc, argv, builtin_commit_usage,
1418 prefix, current_head, &s);
1419 if (dry_run)
1420 return dry_run_commit(argc, argv, prefix, current_head, &s);
1421 index_file = prepare_index(argc, argv, prefix, current_head, 0);
1423 /* Set up everything for writing the commit object. This includes
1424 running hooks, writing the trees, and interacting with the user. */
1425 if (!prepare_to_commit(index_file, prefix,
1426 current_head, &s, &author_ident)) {
1427 rollback_index_files();
1428 return 1;
1429 }
1431 /* Determine parents */
1432 reflog_msg = getenv("GIT_REFLOG_ACTION");
1433 if (!current_head) {
1434 if (!reflog_msg)
1435 reflog_msg = "commit (initial)";
1436 } else if (amend) {
1437 struct commit_list *c;
1439 if (!reflog_msg)
1440 reflog_msg = "commit (amend)";
1441 for (c = current_head->parents; c; c = c->next)
1442 pptr = &commit_list_insert(c->item, pptr)->next;
1443 } else if (whence == FROM_MERGE) {
1444 struct strbuf m = STRBUF_INIT;
1445 FILE *fp;
1447 if (!reflog_msg)
1448 reflog_msg = "commit (merge)";
1449 pptr = &commit_list_insert(current_head, pptr)->next;
1450 fp = fopen(git_path("MERGE_HEAD"), "r");
1451 if (fp == NULL)
1452 die_errno(_("could not open '%s' for reading"),
1453 git_path("MERGE_HEAD"));
1454 while (strbuf_getline(&m, fp, '\n') != EOF) {
1455 struct commit *parent;
1457 parent = get_merge_parent(m.buf);
1458 if (!parent)
1459 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1460 pptr = &commit_list_insert(parent, pptr)->next;
1461 }
1462 fclose(fp);
1463 strbuf_release(&m);
1464 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1465 if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1466 die_errno(_("could not read MERGE_MODE"));
1467 if (!strcmp(sb.buf, "no-ff"))
1468 allow_fast_forward = 0;
1469 }
1470 if (allow_fast_forward)
1471 parents = reduce_heads(parents);
1472 } else {
1473 if (!reflog_msg)
1474 reflog_msg = (whence == FROM_CHERRY_PICK)
1475 ? "commit (cherry-pick)"
1476 : "commit";
1477 pptr = &commit_list_insert(current_head, pptr)->next;
1478 }
1480 /* Finally, get the commit message */
1481 strbuf_reset(&sb);
1482 if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1483 int saved_errno = errno;
1484 rollback_index_files();
1485 die(_("could not read commit message: %s"), strerror(saved_errno));
1486 }
1488 /* Truncate the message just before the diff, if any. */
1489 if (verbose) {
1490 p = strstr(sb.buf, "\ndiff --git ");
1491 if (p != NULL)
1492 strbuf_setlen(&sb, p - sb.buf + 1);
1493 }
1495 if (cleanup_mode != CLEANUP_NONE)
1496 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1497 if (message_is_empty(&sb) && !allow_empty_message) {
1498 rollback_index_files();
1499 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
1500 exit(1);
1501 }
1503 if (amend) {
1504 const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1505 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1506 } else {
1507 struct commit_extra_header **tail = &extra;
1508 append_merge_tag_headers(parents, &tail);
1509 }
1511 if (commit_tree_extended(&sb, active_cache_tree->sha1, parents, sha1,
1512 author_ident.buf, sign_commit, extra)) {
1513 rollback_index_files();
1514 die(_("failed to write commit object"));
1515 }
1516 strbuf_release(&author_ident);
1517 free_commit_extra_headers(extra);
1519 ref_lock = lock_any_ref_for_update("HEAD",
1520 !current_head
1521 ? NULL
1522 : current_head->object.sha1,
1523 0);
1525 nl = strchr(sb.buf, '\n');
1526 if (nl)
1527 strbuf_setlen(&sb, nl + 1 - sb.buf);
1528 else
1529 strbuf_addch(&sb, '\n');
1530 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1531 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1533 if (!ref_lock) {
1534 rollback_index_files();
1535 die(_("cannot lock HEAD ref"));
1536 }
1537 if (write_ref_sha1(ref_lock, sha1, sb.buf) < 0) {
1538 rollback_index_files();
1539 die(_("cannot update HEAD ref"));
1540 }
1542 unlink(git_path("CHERRY_PICK_HEAD"));
1543 unlink(git_path("REVERT_HEAD"));
1544 unlink(git_path("MERGE_HEAD"));
1545 unlink(git_path("MERGE_MSG"));
1546 unlink(git_path("MERGE_MODE"));
1547 unlink(git_path("SQUASH_MSG"));
1549 if (commit_index_files())
1550 die (_("Repository has been updated, but unable to write\n"
1551 "new_index file. Check that disk is not full or quota is\n"
1552 "not exceeded, and then \"git reset HEAD\" to recover."));
1554 rerere(0);
1555 run_hook(get_index_file(), "post-commit", NULL);
1556 if (amend && !no_post_rewrite) {
1557 struct notes_rewrite_cfg *cfg;
1558 cfg = init_copy_notes_for_rewrite("amend");
1559 if (cfg) {
1560 /* we are amending, so current_head is not NULL */
1561 copy_note_for_rewrite(cfg, current_head->object.sha1, sha1);
1562 finish_copy_notes_for_rewrite(cfg);
1563 }
1564 run_rewrite_hook(current_head->object.sha1, sha1);
1565 }
1566 if (!quiet)
1567 print_summary(prefix, sha1, !current_head);
1569 return 0;
1570 }