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