commit: fix patch hunk editing with "commit -p -m"
[git/git.git] / builtin / commit.c
CommitLineData
f5bbc322
KH
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"
6b2f2d98 10#include "color.h"
2888605c 11#include "dir.h"
f5bbc322
KH
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"
c455c87c 24#include "string-list.h"
5b2fd956 25#include "rerere.h"
fa9dcf80 26#include "unpack-trees.h"
76e2f7ce 27#include "quote.h"
302ad7a9 28#include "submodule.h"
ba3c69a9 29#include "gpg-interface.h"
323d0530 30#include "column.h"
5ed75e2a 31#include "sequencer.h"
49c24704 32#include "notes-utils.h"
ea16794e 33#include "mailmap.h"
f5bbc322
KH
34
35static const char * const builtin_commit_usage[] = {
d32805dc 36 N_("git commit [options] [--] <pathspec>..."),
f5bbc322
KH
37 NULL
38};
39
2f02b25f 40static const char * const builtin_status_usage[] = {
d32805dc 41 N_("git status [options] [--] <pathspec>..."),
2f02b25f
SB
42 NULL
43};
44
49ff9a7a 45static const char implicit_ident_advice[] =
fc88e316 46N_("Your name and email address were configured automatically based\n"
49ff9a7a
JK
47"on your username and hostname. Please check that they are accurate.\n"
48"You can suppress this message by setting them explicitly:\n"
49"\n"
8bb45b25 50" git config --global user.name \"Your Name\"\n"
49ff9a7a
JK
51" git config --global user.email you@example.com\n"
52"\n"
3f142468 53"After doing this, you may fix the identity used for this commit with:\n"
49ff9a7a 54"\n"
fc88e316 55" git commit --amend --reset-author\n");
49ff9a7a 56
f197ed2f 57static const char empty_amend_advice[] =
fc88e316 58N_("You asked to amend the most recent commit, but doing so would make\n"
f197ed2f 59"it empty. You can repeat your command with --allow-empty, or you can\n"
fc88e316 60"remove the commit entirely with \"git reset HEAD^\".\n");
f197ed2f 61
37f7a857 62static const char empty_cherry_pick_advice[] =
6c80cd29 63N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
37f7a857
JS
64"If you wish to commit it anyway, use:\n"
65"\n"
66" git commit --allow-empty\n"
c17592a7
JK
67"\n");
68
69static const char empty_cherry_pick_advice_single[] =
70N_("Otherwise, please use 'git reset'\n");
71
72static const char empty_cherry_pick_advice_multi[] =
73N_("If you wish to skip this commit, use:\n"
37f7a857 74"\n"
c17592a7
JK
75" git reset\n"
76"\n"
77"Then \"git cherry-pick --continue\" will resume cherry-picking\n"
78"the remaining commits.\n");
37f7a857 79
37f7a857 80static const char *use_message_buffer;
f5bbc322 81static const char commit_editmsg[] = "COMMIT_EDITMSG";
2888605c
JH
82static struct lock_file index_lock; /* real index */
83static struct lock_file false_lock; /* used only for partial commits */
84static enum {
85 COMMIT_AS_IS = 1,
86 COMMIT_NORMAL,
4b05548f 87 COMMIT_PARTIAL
2888605c 88} commit_style;
f5bbc322 89
dbd0f5c7 90static const char *logfile, *force_author;
984c6e7e 91static const char *template_file;
37f7a857
JS
92/*
93 * The _message variables are commit names from which to take
94 * the commit message and/or authorship.
95 */
96static const char *author_message, *author_message_buffer;
f5bbc322 97static char *edit_message, *use_message;
89ac1223 98static char *fixup_message, *squash_message;
ca1ba201
JH
99static int all, also, interactive, patch_interactive, only, amend, signoff;
100static int edit_flag = -1; /* unspecified */
c51f6cee 101static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
c9b5fde7 102static int no_post_rewrite, allow_empty_message;
46a958b3 103static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
ba3c69a9
JH
104static char *sign_commit;
105
5f065737
AR
106/*
107 * The default commit message cleanup mode will remove the lines
108 * beginning with # (shell comments) and leading and trailing
109 * whitespaces (empty lines or containing only whitespaces)
110 * if editor is used, and only the whitespaces if the message
111 * is specified explicitly.
112 */
113static enum {
114 CLEANUP_SPACE,
115 CLEANUP_NONE,
4b05548f 116 CLEANUP_ALL
5f065737 117} cleanup_mode;
51fb3a3d 118static const char *cleanup_arg;
f5bbc322 119
37f7a857 120static enum commit_whence whence;
c17592a7 121static int sequencer_in_use;
06bb643b 122static int use_editor = 1, include_status = 1;
25206778 123static int show_ignored_in_status, have_option_m;
3b6aeb3c 124static const char *only_include_assumed;
2c47789d 125static struct strbuf message = STRBUF_INIT;
f9568530 126
84b4202d 127static enum status_format {
f3f47a1e 128 STATUS_FORMAT_NONE = 0,
7c9f7038
JK
129 STATUS_FORMAT_LONG,
130 STATUS_FORMAT_SHORT,
84b4202d
JH
131 STATUS_FORMAT_PORCELAIN,
132
133 STATUS_FORMAT_UNSPECIFIED
134} status_format = STATUS_FORMAT_UNSPECIFIED;
7c9f7038 135
f9568530
JS
136static int opt_parse_m(const struct option *opt, const char *arg, int unset)
137{
138 struct strbuf *buf = opt->value;
25206778
RS
139 if (unset) {
140 have_option_m = 0;
f9568530 141 strbuf_setlen(buf, 0);
25206778
RS
142 } else {
143 have_option_m = 1;
a24a41ea
BC
144 if (buf->len)
145 strbuf_addch(buf, '\n');
f9568530 146 strbuf_addstr(buf, arg);
a24a41ea 147 strbuf_complete_line(buf);
f9568530
JS
148 }
149 return 0;
150}
f5bbc322 151
37f7a857
JS
152static void determine_whence(struct wt_status *s)
153{
154 if (file_exists(git_path("MERGE_HEAD")))
155 whence = FROM_MERGE;
c17592a7 156 else if (file_exists(git_path("CHERRY_PICK_HEAD"))) {
37f7a857 157 whence = FROM_CHERRY_PICK;
c17592a7
JK
158 if (file_exists(git_path("sequencer")))
159 sequencer_in_use = 1;
160 }
37f7a857
JS
161 else
162 whence = FROM_COMMIT;
163 if (s)
164 s->whence = whence;
165}
166
5c25dfaa
MM
167static void status_init_config(struct wt_status *s, config_fn_t fn)
168{
169 wt_status_prepare(s);
170 gitmodules_config();
171 git_config(fn, s);
172 determine_whence(s);
6a964f57 173 s->hints = advice_status_hints; /* must come after git_config() */
5c25dfaa
MM
174}
175
2888605c
JH
176static void rollback_index_files(void)
177{
178 switch (commit_style) {
179 case COMMIT_AS_IS:
180 break; /* nothing to do */
181 case COMMIT_NORMAL:
182 rollback_lock_file(&index_lock);
183 break;
184 case COMMIT_PARTIAL:
185 rollback_lock_file(&index_lock);
186 rollback_lock_file(&false_lock);
187 break;
188 }
189}
190
5a9dd399 191static int commit_index_files(void)
2888605c 192{
5a9dd399
BC
193 int err = 0;
194
2888605c
JH
195 switch (commit_style) {
196 case COMMIT_AS_IS:
197 break; /* nothing to do */
198 case COMMIT_NORMAL:
5a9dd399 199 err = commit_lock_file(&index_lock);
2888605c
JH
200 break;
201 case COMMIT_PARTIAL:
5a9dd399 202 err = commit_lock_file(&index_lock);
2888605c
JH
203 rollback_lock_file(&false_lock);
204 break;
205 }
5a9dd399
BC
206
207 return err;
2888605c
JH
208}
209
210/*
211 * Take a union of paths in the index and the named tree (typically, "HEAD"),
212 * and return the paths that match the given pattern in list.
213 */
c455c87c 214static int list_paths(struct string_list *list, const char *with_tree,
17ddc66e 215 const char *prefix, const struct pathspec *pattern)
2888605c
JH
216{
217 int i;
218 char *m;
219
17ddc66e 220 if (!pattern->nr)
ea2d4ed3
JK
221 return 0;
222
17ddc66e 223 m = xcalloc(1, pattern->nr);
2888605c 224
8894d535 225 if (with_tree) {
f950eb95 226 char *max_prefix = common_prefix(pattern);
5879f568
CB
227 overlay_tree_on_cache(with_tree, max_prefix ? max_prefix : prefix);
228 free(max_prefix);
8894d535 229 }
2888605c
JH
230
231 for (i = 0; i < active_nr; i++) {
9c5e6c80 232 const struct cache_entry *ce = active_cache[i];
7fce6e3c
NTND
233 struct string_list_item *item;
234
7a51ed66 235 if (ce->ce_flags & CE_UPDATE)
e87e22d0 236 continue;
17ddc66e 237 if (!match_pathspec_depth(pattern, ce->name, ce_namelen(ce), 0, m))
2888605c 238 continue;
78a395d3 239 item = string_list_insert(list, ce->name);
7fce6e3c
NTND
240 if (ce_skip_worktree(ce))
241 item->util = item; /* better a valid pointer than a fake one */
2888605c
JH
242 }
243
0f64bfa9 244 return report_path_error(m, pattern, prefix);
2888605c
JH
245}
246
c455c87c 247static void add_remove_files(struct string_list *list)
2888605c
JH
248{
249 int i;
250 for (i = 0; i < list->nr; i++) {
d177cab0 251 struct stat st;
c455c87c 252 struct string_list_item *p = &(list->items[i]);
d177cab0 253
7fce6e3c
NTND
254 /* p->util is skip-worktree */
255 if (p->util)
b4d1690d 256 continue;
d177cab0 257
c455c87c
JS
258 if (!lstat(p->string, &st)) {
259 if (add_to_cache(p->string, &st, 0))
8a6179bc 260 die(_("updating files failed"));
960b8ad1 261 } else
c455c87c 262 remove_file_from_cache(p->string);
2888605c
JH
263 }
264}
265
06bb643b 266static void create_base_index(const struct commit *current_head)
fa9dcf80
LT
267{
268 struct tree *tree;
269 struct unpack_trees_options opts;
270 struct tree_desc t;
271
06bb643b 272 if (!current_head) {
fa9dcf80
LT
273 discard_cache();
274 return;
275 }
276
277 memset(&opts, 0, sizeof(opts));
278 opts.head_idx = 1;
279 opts.index_only = 1;
280 opts.merge = 1;
34110cd4
LT
281 opts.src_index = &the_index;
282 opts.dst_index = &the_index;
fa9dcf80
LT
283
284 opts.fn = oneway_merge;
06bb643b 285 tree = parse_tree_indirect(current_head->object.sha1);
fa9dcf80 286 if (!tree)
8a6179bc 287 die(_("failed to unpack HEAD tree object"));
fa9dcf80
LT
288 parse_tree(tree);
289 init_tree_desc(&t, tree->buffer, tree->size);
203a2fe1
DB
290 if (unpack_trees(1, &t, &opts))
291 exit(128); /* We've already reported the error, finish dying */
fa9dcf80
LT
292}
293
d38a30df
MM
294static void refresh_cache_or_die(int refresh_flags)
295{
296 /*
297 * refresh_flags contains REFRESH_QUIET, so the only errors
298 * are for unmerged entries.
299 */
300 if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN))
301 die_resolve_conflict("commit");
302}
303
06bb643b
JH
304static char *prepare_index(int argc, const char **argv, const char *prefix,
305 const struct commit *current_head, int is_status)
f5bbc322
KH
306{
307 int fd;
c455c87c 308 struct string_list partial;
6654c889 309 struct pathspec pathspec;
1020d087 310 char *old_index_env = NULL;
50b7e70f 311 int refresh_flags = REFRESH_QUIET;
f5bbc322 312
50b7e70f
JH
313 if (is_status)
314 refresh_flags |= REFRESH_UNMERGED;
6654c889
NTND
315 parse_pathspec(&pathspec, 0,
316 PATHSPEC_PREFER_FULL,
317 prefix, argv);
f5bbc322 318
5ab2a2da 319 if (read_cache_preload(&pathspec) < 0)
8a6179bc 320 die(_("index file corrupt"));
671c9b7e 321
1020d087
CI
322 if (interactive) {
323 fd = hold_locked_index(&index_lock, 1);
324
325 refresh_cache_or_die(refresh_flags);
326
327 if (write_cache(fd, active_cache, active_nr) ||
328 close_lock_file(&index_lock))
329 die(_("unable to create temporary index"));
330
331 old_index_env = getenv(INDEX_ENVIRONMENT);
332 setenv(INDEX_ENVIRONMENT, index_lock.filename, 1);
333
b4bd4668 334 if (interactive_add(argc, argv, prefix, patch_interactive) != 0)
1020d087
CI
335 die(_("interactive add failed"));
336
337 if (old_index_env && *old_index_env)
338 setenv(INDEX_ENVIRONMENT, old_index_env, 1);
339 else
340 unsetenv(INDEX_ENVIRONMENT);
341
342 discard_cache();
343 read_cache_from(index_lock.filename);
344
345 commit_style = COMMIT_NORMAL;
346 return index_lock.filename;
347 }
348
2888605c
JH
349 /*
350 * Non partial, non as-is commit.
351 *
352 * (1) get the real index;
353 * (2) update the_index as necessary;
354 * (3) write the_index out to the real index (still locked);
355 * (4) return the name of the locked index file.
356 *
357 * The caller should run hooks on the locked real index, and
358 * (A) if all goes well, commit the real index;
359 * (B) on failure, rollback the real index.
360 */
6654c889 361 if (all || (also && pathspec.nr)) {
1f2362a9 362 fd = hold_locked_index(&index_lock, 1);
3efe8e43 363 add_files_to_cache(also ? prefix : NULL, &pathspec, 0);
d38a30df 364 refresh_cache_or_die(refresh_flags);
e859c69b 365 update_main_cache_tree(WRITE_TREE_SILENT);
4ed7cd3a
BC
366 if (write_cache(fd, active_cache, active_nr) ||
367 close_lock_file(&index_lock))
8a6179bc 368 die(_("unable to write new_index file"));
2888605c
JH
369 commit_style = COMMIT_NORMAL;
370 return index_lock.filename;
f5bbc322
KH
371 }
372
2888605c
JH
373 /*
374 * As-is commit.
375 *
376 * (1) return the name of the real index file.
377 *
73276235
MH
378 * The caller should run hooks on the real index,
379 * and create commit from the_index.
2888605c
JH
380 * We still need to refresh the index here.
381 */
6654c889 382 if (!only && !pathspec.nr) {
2888605c 383 fd = hold_locked_index(&index_lock, 1);
d38a30df 384 refresh_cache_or_die(refresh_flags);
d5f5d0a9 385 if (active_cache_changed) {
e859c69b 386 update_main_cache_tree(WRITE_TREE_SILENT);
d5f5d0a9
JH
387 if (write_cache(fd, active_cache, active_nr) ||
388 commit_locked_index(&index_lock))
8a6179bc 389 die(_("unable to write new_index file"));
d5f5d0a9
JH
390 } else {
391 rollback_lock_file(&index_lock);
392 }
2888605c 393 commit_style = COMMIT_AS_IS;
f5bbc322
KH
394 return get_index_file();
395 }
396
2888605c
JH
397 /*
398 * A partial commit.
399 *
400 * (0) find the set of affected paths;
401 * (1) get lock on the real index file;
402 * (2) update the_index with the given paths;
403 * (3) write the_index out to the real index (still locked);
404 * (4) get lock on the false index file;
405 * (5) reset the_index from HEAD;
406 * (6) update the_index the same way as (2);
407 * (7) write the_index out to the false index file;
408 * (8) return the name of the false index file (still locked);
409 *
410 * The caller should run hooks on the locked false index, and
411 * create commit from it. Then
412 * (A) if all goes well, commit the real index;
413 * (B) on failure, rollback the real index;
414 * In either case, rollback the false index.
415 */
416 commit_style = COMMIT_PARTIAL;
417
b0cea47e
ÆAB
418 if (whence != FROM_COMMIT) {
419 if (whence == FROM_MERGE)
420 die(_("cannot do a partial commit during a merge."));
421 else if (whence == FROM_CHERRY_PICK)
422 die(_("cannot do a partial commit during a cherry-pick."));
423 }
2888605c
JH
424
425 memset(&partial, 0, sizeof(partial));
c455c87c 426 partial.strdup_strings = 1;
17ddc66e 427 if (list_paths(&partial, !current_head ? NULL : "HEAD", prefix, &pathspec))
2888605c
JH
428 exit(1);
429
430 discard_cache();
431 if (read_cache() < 0)
8a6179bc 432 die(_("cannot read the index"));
2888605c
JH
433
434 fd = hold_locked_index(&index_lock, 1);
435 add_remove_files(&partial);
ef12b50d 436 refresh_cache(REFRESH_QUIET);
4ed7cd3a
BC
437 if (write_cache(fd, active_cache, active_nr) ||
438 close_lock_file(&index_lock))
8a6179bc 439 die(_("unable to write new_index file"));
f5bbc322 440
2888605c 441 fd = hold_lock_file_for_update(&false_lock,
a157400c
JH
442 git_path("next-index-%"PRIuMAX,
443 (uintmax_t) getpid()),
acd3b9ec 444 LOCK_DIE_ON_ERROR);
fa9dcf80 445
06bb643b 446 create_base_index(current_head);
2888605c 447 add_remove_files(&partial);
d37d3203 448 refresh_cache(REFRESH_QUIET);
f5bbc322 449
4ed7cd3a
BC
450 if (write_cache(fd, active_cache, active_nr) ||
451 close_lock_file(&false_lock))
8a6179bc 452 die(_("unable to write temporary index file"));
959ba670
JK
453
454 discard_cache();
455 read_cache_from(false_lock.filename);
456
2888605c 457 return false_lock.filename;
f5bbc322
KH
458}
459
d249b098
JH
460static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
461 struct wt_status *s)
f5bbc322 462{
76e2f7ce
JH
463 unsigned char sha1[20];
464
d249b098
JH
465 if (s->relative_paths)
466 s->prefix = prefix;
f5bbc322
KH
467
468 if (amend) {
d249b098
JH
469 s->amend = 1;
470 s->reference = "HEAD^1";
f5bbc322 471 }
d249b098
JH
472 s->verbose = verbose;
473 s->index_file = index_file;
474 s->fp = fp;
475 s->nowarn = nowarn;
76e2f7ce 476 s->is_initial = get_sha1(s->reference, sha1) ? 1 : 0;
f5bbc322 477
76e2f7ce 478 wt_status_collect(s);
7c9f7038
JK
479
480 switch (status_format) {
481 case STATUS_FORMAT_SHORT:
d4a6bf1f 482 wt_shortstatus_print(s);
7c9f7038
JK
483 break;
484 case STATUS_FORMAT_PORCELAIN:
3207a3a2 485 wt_porcelain_print(s);
7c9f7038 486 break;
84b4202d
JH
487 case STATUS_FORMAT_UNSPECIFIED:
488 die("BUG: finalize_deferred_config() should have been called");
489 break;
f3f47a1e 490 case STATUS_FORMAT_NONE:
7c9f7038
JK
491 case STATUS_FORMAT_LONG:
492 wt_status_print(s);
493 break;
494 }
f5bbc322 495
d249b098 496 return s->commitable;
f5bbc322
KH
497}
498
06bb643b 499static int is_a_merge(const struct commit *current_head)
ec84bd00 500{
06bb643b 501 return !!(current_head->parents && current_head->parents->next);
ec84bd00
PB
502}
503
7dfe8ad6
JH
504static void export_one(const char *var, const char *s, const char *e, int hack)
505{
506 struct strbuf buf = STRBUF_INIT;
507 if (hack)
508 strbuf_addch(&buf, hack);
509 strbuf_addf(&buf, "%.*s", (int)(e - s), s);
510 setenv(var, buf.buf, 1);
511 strbuf_release(&buf);
512}
513
e27ddb64
JH
514static int sane_ident_split(struct ident_split *person)
515{
516 if (!person->name_begin || !person->name_end ||
517 person->name_begin == person->name_end)
518 return 0; /* no human readable name */
519 if (!person->mail_begin || !person->mail_end ||
520 person->mail_begin == person->mail_end)
521 return 0; /* no usable mail */
522 if (!person->date_begin || !person->date_end ||
523 !person->tz_begin || !person->tz_end)
524 return 0;
525 return 1;
526}
527
4c28e4ad 528static void determine_author_info(struct strbuf *author_ident)
a45d46ba
SB
529{
530 char *name, *email, *date;
7dfe8ad6 531 struct ident_split author;
a45d46ba
SB
532
533 name = getenv("GIT_AUTHOR_NAME");
534 email = getenv("GIT_AUTHOR_EMAIL");
535 date = getenv("GIT_AUTHOR_DATE");
536
37f7a857 537 if (author_message) {
a45d46ba 538 const char *a, *lb, *rb, *eol;
2c733fb2 539 size_t len;
a45d46ba 540
37f7a857 541 a = strstr(author_message_buffer, "\nauthor ");
a45d46ba 542 if (!a)
6c80cd29 543 die(_("invalid commit: %s"), author_message);
a45d46ba 544
fb7749e4
JN
545 lb = strchrnul(a + strlen("\nauthor "), '<');
546 rb = strchrnul(lb, '>');
547 eol = strchrnul(rb, '\n');
548 if (!*lb || !*rb || !*eol)
6c80cd29 549 die(_("invalid commit: %s"), author_message);
a45d46ba 550
fb7749e4
JN
551 if (lb == a + strlen("\nauthor "))
552 /* \nauthor <foo@example.com> */
553 name = xcalloc(1, 1);
554 else
555 name = xmemdupz(a + strlen("\nauthor "),
556 (lb - strlen(" ") -
557 (a + strlen("\nauthor "))));
558 email = xmemdupz(lb + strlen("<"), rb - (lb + strlen("<")));
2c733fb2
JH
559 len = eol - (rb + strlen("> "));
560 date = xmalloc(len + 2);
561 *date = '@';
562 memcpy(date + 1, rb + strlen("> "), len);
563 date[len + 1] = '\0';
a45d46ba
SB
564 }
565
566 if (force_author) {
567 const char *lb = strstr(force_author, " <");
568 const char *rb = strchr(force_author, '>');
569
570 if (!lb || !rb)
8a6179bc 571 die(_("malformed --author parameter"));
a45d46ba
SB
572 name = xstrndup(force_author, lb - force_author);
573 email = xstrndup(lb + 2, rb - (lb + 2));
574 }
575
02b47cd7
MV
576 if (force_date)
577 date = force_date;
f9bc573f 578 strbuf_addstr(author_ident, fmt_ident(name, email, date, IDENT_STRICT));
e27ddb64
JH
579 if (!split_ident_line(&author, author_ident->buf, author_ident->len) &&
580 sane_ident_split(&author)) {
7dfe8ad6
JH
581 export_one("GIT_AUTHOR_NAME", author.name_begin, author.name_end, 0);
582 export_one("GIT_AUTHOR_EMAIL", author.mail_begin, author.mail_end, 0);
583 export_one("GIT_AUTHOR_DATE", author.date_begin, author.tz_end, '@');
584 }
a45d46ba
SB
585}
586
4c28e4ad
JH
587static char *cut_ident_timestamp_part(char *string)
588{
589 char *ket = strrchr(string, '>');
590 if (!ket || ket[1] != ' ')
8a6179bc 591 die(_("Malformed ident string: '%s'"), string);
4c28e4ad
JH
592 *++ket = '\0';
593 return ket;
594}
595
d249b098 596static int prepare_to_commit(const char *index_file, const char *prefix,
06bb643b 597 struct commit *current_head,
4c28e4ad
JH
598 struct wt_status *s,
599 struct strbuf *author_ident)
f5bbc322
KH
600{
601 struct stat statbuf;
4c28e4ad 602 struct strbuf committer_ident = STRBUF_INIT;
bc5d248a 603 int commitable, saved_color_setting;
f285a2d7 604 struct strbuf sb = STRBUF_INIT;
f5bbc322 605 char *buffer;
8089c85b
PB
606 const char *hook_arg1 = NULL;
607 const char *hook_arg2 = NULL;
bb1ae3f6 608 int ident_shown = 0;
8b1ae678 609 int clean_message_contents = (cleanup_mode != CLEANUP_NONE);
2556b996 610 int old_display_comment_prefix;
f5bbc322 611
7dfe8ad6
JH
612 /* This checks and barfs if author is badly specified */
613 determine_author_info(author_ident);
614
15048f8a 615 if (!no_verify && run_commit_hook(use_editor, index_file, "pre-commit", NULL))
ec84bd00 616 return 0;
f5bbc322 617
89ac1223
PN
618 if (squash_message) {
619 /*
620 * Insert the proper subject line before other commit
621 * message options add their content.
622 */
623 if (use_message && !strcmp(use_message, squash_message))
624 strbuf_addstr(&sb, "squash! ");
625 else {
626 struct pretty_print_context ctx = {0};
627 struct commit *c;
628 c = lookup_commit_reference_by_name(squash_message);
629 if (!c)
8a6179bc 630 die(_("could not lookup commit %s"), squash_message);
89ac1223
PN
631 ctx.output_encoding = get_commit_output_encoding();
632 format_commit_message(c, "squash! %s\n\n", &sb,
633 &ctx);
634 }
635 }
636
f9568530
JS
637 if (message.len) {
638 strbuf_addbuf(&sb, &message);
8089c85b 639 hook_arg1 = "message";
f5bbc322
KH
640 } else if (logfile && !strcmp(logfile, "-")) {
641 if (isatty(0))
8a6179bc 642 fprintf(stderr, _("(reading log message from standard input)\n"));
f5bbc322 643 if (strbuf_read(&sb, 0, 0) < 0)
8a6179bc 644 die_errno(_("could not read log from standard input"));
8089c85b 645 hook_arg1 = "message";
f5bbc322
KH
646 } else if (logfile) {
647 if (strbuf_read_file(&sb, logfile, 0) < 0)
8a6179bc 648 die_errno(_("could not read log file '%s'"),
d824cbba 649 logfile);
8089c85b 650 hook_arg1 = "message";
f5bbc322
KH
651 } else if (use_message) {
652 buffer = strstr(use_message_buffer, "\n\n");
d9a93575 653 if (!use_editor && (!buffer || buffer[2] == '\0'))
8a6179bc 654 die(_("commit has empty message"));
f5bbc322 655 strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
8089c85b
PB
656 hook_arg1 = "commit";
657 hook_arg2 = use_message;
d71b8ba7
PN
658 } else if (fixup_message) {
659 struct pretty_print_context ctx = {0};
660 struct commit *commit;
661 commit = lookup_commit_reference_by_name(fixup_message);
662 if (!commit)
8a6179bc 663 die(_("could not lookup commit %s"), fixup_message);
d71b8ba7
PN
664 ctx.output_encoding = get_commit_output_encoding();
665 format_commit_message(commit, "fixup! %s\n\n",
666 &sb, &ctx);
667 hook_arg1 = "message";
f5bbc322
KH
668 } else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
669 if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
8a6179bc 670 die_errno(_("could not read MERGE_MSG"));
8089c85b 671 hook_arg1 = "merge";
f5bbc322
KH
672 } else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
673 if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
8a6179bc 674 die_errno(_("could not read SQUASH_MSG"));
8089c85b 675 hook_arg1 = "squash";
2140b140 676 } else if (template_file) {
f5bbc322 677 if (strbuf_read_file(&sb, template_file, 0) < 0)
8a6179bc 678 die_errno(_("could not read '%s'"), template_file);
8089c85b 679 hook_arg1 = "template";
8b1ae678 680 clean_message_contents = 0;
f5bbc322
KH
681 }
682
8089c85b 683 /*
37f7a857
JS
684 * The remaining cases don't modify the template message, but
685 * just set the argument(s) to the prepare-commit-msg hook.
8089c85b 686 */
37f7a857 687 else if (whence == FROM_MERGE)
8089c85b 688 hook_arg1 = "merge";
37f7a857
JS
689 else if (whence == FROM_CHERRY_PICK) {
690 hook_arg1 = "commit";
691 hook_arg2 = "CHERRY_PICK_HEAD";
692 }
8089c85b 693
89ac1223
PN
694 if (squash_message) {
695 /*
696 * If squash_commit was used for the commit subject,
697 * then we're possibly hijacking other commit log options.
698 * Reset the hook args to tell the real story.
699 */
700 hook_arg1 = "message";
701 hook_arg2 = "";
702 }
703
37f3012f
JN
704 s->fp = fopen(git_path(commit_editmsg), "w");
705 if (s->fp == NULL)
8a6179bc 706 die_errno(_("could not open '%s'"), git_path(commit_editmsg));
f5bbc322 707
2556b996
MM
708 /* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */
709 old_display_comment_prefix = s->display_comment_prefix;
710 s->display_comment_prefix = 1;
711
ea9882bf
MM
712 /*
713 * Most hints are counter-productive when the commit has
714 * already started.
715 */
716 s->hints = 0;
717
8b1ae678 718 if (clean_message_contents)
5f065737 719 stripspace(&sb, 0);
f5bbc322
KH
720
721 if (signoff) {
5ed75e2a
MV
722 /*
723 * See if we have a Conflicts: block at the end. If yes, count
724 * its size, so we can ignore it.
725 */
726 int ignore_footer = 0;
727 int i, eol, previous = 0;
728 const char *nl;
729
730 for (i = 0; i < sb.len; i++) {
731 nl = memchr(sb.buf + i, '\n', sb.len - i);
732 if (nl)
733 eol = nl - sb.buf;
734 else
735 eol = sb.len;
59556548 736 if (starts_with(sb.buf + previous, "\nConflicts:\n")) {
5ed75e2a
MV
737 ignore_footer = sb.len - previous;
738 break;
739 }
740 while (i < eol)
741 i++;
742 previous = eol;
2150554b 743 }
5ed75e2a 744
bab4d109 745 append_signoff(&sb, ignore_footer, 0);
f5bbc322
KH
746 }
747
37f3012f 748 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
8a6179bc 749 die_errno(_("could not write commit template"));
13208572 750
f5bbc322
KH
751 strbuf_release(&sb);
752
bb1ae3f6 753 /* This checks if committer ident is explicitly given */
f20f3878 754 strbuf_addstr(&committer_ident, git_committer_info(IDENT_STRICT));
bed575e4 755 if (use_editor && include_status) {
4c28e4ad 756 char *ai_tmp, *ci_tmp;
37f7a857 757 if (whence != FROM_COMMIT)
b926c0d1 758 status_printf_ln(s, GIT_COLOR_NORMAL,
b0cea47e
ÆAB
759 whence == FROM_MERGE
760 ? _("\n"
761 "It looks like you may be committing a merge.\n"
762 "If this is not correct, please remove the file\n"
763 " %s\n"
764 "and try again.\n")
765 : _("\n"
766 "It looks like you may be committing a cherry-pick.\n"
767 "If this is not correct, please remove the file\n"
768 " %s\n"
769 "and try again.\n"),
37f7a857
JS
770 git_path(whence == FROM_MERGE
771 ? "MERGE_HEAD"
772 : "CHERRY_PICK_HEAD"));
ec84bd00 773
b926c0d1 774 fprintf(s->fp, "\n");
ec84bd00 775 if (cleanup_mode == CLEANUP_ALL)
4064e665
ÆAB
776 status_printf(s, GIT_COLOR_NORMAL,
777 _("Please enter the commit message for your changes."
eff80a9f
JH
778 " Lines starting\nwith '%c' will be ignored, and an empty"
779 " message aborts the commit.\n"), comment_line_char);
ec84bd00 780 else /* CLEANUP_SPACE, that is. */
4064e665
ÆAB
781 status_printf(s, GIT_COLOR_NORMAL,
782 _("Please enter the commit message for your changes."
eff80a9f
JH
783 " Lines starting\n"
784 "with '%c' will be kept; you may remove them"
785 " yourself if you want to.\n"
786 "An empty message aborts the commit.\n"), comment_line_char);
ec84bd00 787 if (only_include_assumed)
b926c0d1
JN
788 status_printf_ln(s, GIT_COLOR_NORMAL,
789 "%s", only_include_assumed);
ec84bd00 790
4c28e4ad
JH
791 ai_tmp = cut_ident_timestamp_part(author_ident->buf);
792 ci_tmp = cut_ident_timestamp_part(committer_ident.buf);
793 if (strcmp(author_ident->buf, committer_ident.buf))
b926c0d1 794 status_printf_ln(s, GIT_COLOR_NORMAL,
fe8165cd
ÆAB
795 _("%s"
796 "Author: %s"),
b926c0d1 797 ident_shown++ ? "" : "\n",
4c28e4ad 798 author_ident->buf);
e83dbe80 799
d6991cee 800 if (!committer_ident_sufficiently_given())
b926c0d1 801 status_printf_ln(s, GIT_COLOR_NORMAL,
fe8165cd
ÆAB
802 _("%s"
803 "Committer: %s"),
b926c0d1 804 ident_shown++ ? "" : "\n",
4c28e4ad 805 committer_ident.buf);
bb1ae3f6
SB
806
807 if (ident_shown)
b926c0d1 808 status_printf_ln(s, GIT_COLOR_NORMAL, "");
bb1ae3f6 809
d249b098
JH
810 saved_color_setting = s->use_color;
811 s->use_color = 0;
37f3012f 812 commitable = run_status(s->fp, index_file, prefix, 1, s);
d249b098 813 s->use_color = saved_color_setting;
4c28e4ad
JH
814
815 *ai_tmp = ' ';
816 *ci_tmp = ' ';
ec84bd00 817 } else {
d616a239 818 unsigned char sha1[20];
fbcf1184 819 const char *parent = "HEAD";
7168624c 820
7168624c 821 if (!active_nr && read_cache() < 0)
8a6179bc 822 die(_("Cannot read index"));
7168624c 823
fbcf1184
JH
824 if (amend)
825 parent = "HEAD^1";
826
d616a239 827 if (get_sha1(parent, sha1))
ec84bd00 828 commitable = !!active_nr;
75f3ff2e
SB
829 else
830 commitable = index_differs_from(parent, 0);
ec84bd00 831 }
4c28e4ad 832 strbuf_release(&committer_ident);
d616a239 833
37f3012f 834 fclose(s->fp);
7168624c 835
37f7a857
JS
836 /*
837 * Reject an attempt to record a non-merge empty commit without
838 * explicit --allow-empty. In the cherry-pick case, it may be
839 * empty due to conflict resolution, which the user should okay.
840 */
841 if (!commitable && whence != FROM_MERGE && !allow_empty &&
06bb643b 842 !(amend && is_a_merge(current_head))) {
2556b996 843 s->display_comment_prefix = old_display_comment_prefix;
d249b098 844 run_status(stdout, index_file, prefix, 0, s);
f197ed2f 845 if (amend)
fc88e316 846 fputs(_(empty_amend_advice), stderr);
c17592a7 847 else if (whence == FROM_CHERRY_PICK) {
6c80cd29 848 fputs(_(empty_cherry_pick_advice), stderr);
c17592a7
JK
849 if (!sequencer_in_use)
850 fputs(_(empty_cherry_pick_advice_single), stderr);
851 else
852 fputs(_(empty_cherry_pick_advice_multi), stderr);
853 }
ec84bd00 854 return 0;
7168624c
AR
855 }
856
ec84bd00
PB
857 /*
858 * Re-read the index as pre-commit hook could have updated it,
859 * and write it out as a tree. We must do this before we invoke
860 * the editor and after we invoke run_status above.
861 */
862 discard_cache();
863 read_cache_from(index_file);
996277c5 864 if (update_main_cache_tree(0)) {
8a6179bc 865 error(_("Error building trees"));
ec84bd00 866 return 0;
7168624c 867 }
f5bbc322 868
15048f8a
BP
869 if (run_commit_hook(use_editor, index_file, "prepare-commit-msg",
870 git_path(commit_editmsg), hook_arg1, hook_arg2, NULL))
8089c85b 871 return 0;
f5bbc322 872
ec84bd00
PB
873 if (use_editor) {
874 char index[PATH_MAX];
66dbfd55
GV
875 const char *env[2] = { NULL };
876 env[0] = index;
ec84bd00 877 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
7198203a
SB
878 if (launch_editor(git_path(commit_editmsg), NULL, env)) {
879 fprintf(stderr,
8a6179bc 880 _("Please supply the message using either -m or -F option.\n"));
7198203a
SB
881 exit(1);
882 }
ec84bd00 883 }
f5bbc322 884
ec84bd00 885 if (!no_verify &&
15048f8a 886 run_commit_hook(use_editor, index_file, "commit-msg", git_path(commit_editmsg), NULL)) {
ec84bd00
PB
887 return 0;
888 }
f5bbc322 889
ec84bd00 890 return 1;
f5bbc322
KH
891}
892
b2eda9bd 893static int rest_is_empty(struct strbuf *sb, int start)
f5bbc322 894{
b2eda9bd 895 int i, eol;
f5bbc322 896 const char *nl;
f5bbc322
KH
897
898 /* Check if the rest is just whitespace and Signed-of-by's. */
899 for (i = start; i < sb->len; i++) {
900 nl = memchr(sb->buf + i, '\n', sb->len - i);
901 if (nl)
902 eol = nl - sb->buf;
903 else
904 eol = sb->len;
905
906 if (strlen(sign_off_header) <= eol - i &&
59556548 907 starts_with(sb->buf + i, sign_off_header)) {
f5bbc322
KH
908 i = eol;
909 continue;
910 }
911 while (i < eol)
912 if (!isspace(sb->buf[i++]))
913 return 0;
914 }
915
916 return 1;
917}
918
b2eda9bd
JH
919/*
920 * Find out if the message in the strbuf contains only whitespace and
921 * Signed-off-by lines.
922 */
923static int message_is_empty(struct strbuf *sb)
924{
925 if (cleanup_mode == CLEANUP_NONE && sb->len)
926 return 0;
927 return rest_is_empty(sb, 0);
928}
929
930/*
931 * See if the user edited the message in the editor or left what
932 * was in the template intact
933 */
934static int template_untouched(struct strbuf *sb)
935{
936 struct strbuf tmpl = STRBUF_INIT;
937 char *start;
938
939 if (cleanup_mode == CLEANUP_NONE && sb->len)
940 return 0;
941
942 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
943 return 0;
944
945 stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
946 start = (char *)skip_prefix(sb->buf, tmpl.buf);
947 if (!start)
948 start = sb->buf;
949 strbuf_release(&tmpl);
950 return rest_is_empty(sb, start - sb->buf);
951}
952
146ea068
JH
953static const char *find_author_by_nickname(const char *name)
954{
955 struct rev_info revs;
956 struct commit *commit;
957 struct strbuf buf = STRBUF_INIT;
ea16794e 958 struct string_list mailmap = STRING_LIST_INIT_NODUP;
146ea068
JH
959 const char *av[20];
960 int ac = 0;
961
962 init_revisions(&revs, NULL);
963 strbuf_addf(&buf, "--author=%s", name);
964 av[++ac] = "--all";
965 av[++ac] = "-i";
966 av[++ac] = buf.buf;
967 av[++ac] = NULL;
968 setup_revisions(ac, av, &revs, NULL);
ea16794e
AP
969 revs.mailmap = &mailmap;
970 read_mailmap(revs.mailmap, NULL);
971
146ea068
JH
972 prepare_revision_walk(&revs);
973 commit = get_revision(&revs);
974 if (commit) {
dd2e794a
TR
975 struct pretty_print_context ctx = {0};
976 ctx.date_mode = DATE_NORMAL;
146ea068 977 strbuf_release(&buf);
ea16794e
AP
978 format_commit_message(commit, "%aN <%aE>", &buf, &ctx);
979 clear_mailmap(&mailmap);
146ea068
JH
980 return strbuf_detach(&buf, NULL);
981 }
8a6179bc 982 die(_("No existing author found with '%s'"), name);
146ea068
JH
983}
984
76e2f7ce
JH
985
986static void handle_untracked_files_arg(struct wt_status *s)
987{
988 if (!untracked_files_arg)
989 ; /* default already initialized */
990 else if (!strcmp(untracked_files_arg, "no"))
991 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
992 else if (!strcmp(untracked_files_arg, "normal"))
993 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
994 else if (!strcmp(untracked_files_arg, "all"))
995 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
996 else
8a6179bc 997 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
76e2f7ce
JH
998}
999
37f7a857
JS
1000static const char *read_commit_message(const char *name)
1001{
dd0d388c 1002 const char *out_enc;
37f7a857
JS
1003 struct commit *commit;
1004
1005 commit = lookup_commit_reference_by_name(name);
1006 if (!commit)
6c80cd29 1007 die(_("could not lookup commit %s"), name);
37f7a857 1008 out_enc = get_commit_output_encoding();
5a10d236 1009 return logmsg_reencode(commit, NULL, out_enc);
37f7a857
JS
1010}
1011
84b4202d
JH
1012/*
1013 * Enumerate what needs to be propagated when --porcelain
1014 * is not in effect here.
1015 */
1016static struct status_deferred_config {
1017 enum status_format status_format;
1018 int show_branch;
1019} status_deferred_config = {
1020 STATUS_FORMAT_UNSPECIFIED,
1021 -1 /* unspecified */
1022};
1023
1024static void finalize_deferred_config(struct wt_status *s)
1025{
1026 int use_deferred_config = (status_format != STATUS_FORMAT_PORCELAIN &&
1027 !s->null_termination);
1028
1029 if (s->null_termination) {
1030 if (status_format == STATUS_FORMAT_NONE ||
1031 status_format == STATUS_FORMAT_UNSPECIFIED)
1032 status_format = STATUS_FORMAT_PORCELAIN;
1033 else if (status_format == STATUS_FORMAT_LONG)
1034 die(_("--long and -z are incompatible"));
1035 }
1036
1037 if (use_deferred_config && status_format == STATUS_FORMAT_UNSPECIFIED)
1038 status_format = status_deferred_config.status_format;
1039 if (status_format == STATUS_FORMAT_UNSPECIFIED)
1040 status_format = STATUS_FORMAT_NONE;
1041
1042 if (use_deferred_config && s->show_branch < 0)
1043 s->show_branch = status_deferred_config.show_branch;
1044 if (s->show_branch < 0)
1045 s->show_branch = 0;
1046}
1047
2f02b25f 1048static int parse_and_validate_options(int argc, const char *argv[],
036dbbfb 1049 const struct option *options,
dbd0f5c7 1050 const char * const usage[],
d249b098 1051 const char *prefix,
06bb643b 1052 struct commit *current_head,
d249b098 1053 struct wt_status *s)
f5bbc322
KH
1054{
1055 int f = 0;
1056
036dbbfb 1057 argc = parse_options(argc, argv, prefix, options, usage, 0);
84b4202d 1058 finalize_deferred_config(s);
f5bbc322 1059
146ea068
JH
1060 if (force_author && !strchr(force_author, '>'))
1061 force_author = find_author_by_nickname(force_author);
1062
c51f6cee 1063 if (force_author && renew_authorship)
8a6179bc 1064 die(_("Using both --reset-author and --author does not make sense"));
c51f6cee 1065
25206778 1066 if (logfile || have_option_m || use_message || fixup_message)
4803466f 1067 use_editor = 0;
ca1ba201
JH
1068 if (0 <= edit_flag)
1069 use_editor = edit_flag;
f5bbc322 1070
f5bbc322 1071 /* Sanity check options */
06bb643b 1072 if (amend && !current_head)
8a6179bc 1073 die(_("You have nothing to amend."));
b0cea47e
ÆAB
1074 if (amend && whence != FROM_COMMIT) {
1075 if (whence == FROM_MERGE)
1076 die(_("You are in the middle of a merge -- cannot amend."));
1077 else if (whence == FROM_CHERRY_PICK)
1078 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1079 }
89ac1223 1080 if (fixup_message && squash_message)
9c227655 1081 die(_("Options --squash and --fixup cannot be used together"));
f5bbc322
KH
1082 if (use_message)
1083 f++;
1084 if (edit_message)
1085 f++;
d71b8ba7
PN
1086 if (fixup_message)
1087 f++;
f5bbc322
KH
1088 if (logfile)
1089 f++;
1090 if (f > 1)
8a6179bc 1091 die(_("Only one of -c/-C/-F/--fixup can be used."));
f9568530 1092 if (message.len && f > 0)
8a6179bc 1093 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
010c7dbc
JH
1094 if (f || message.len)
1095 template_file = NULL;
f5bbc322
KH
1096 if (edit_message)
1097 use_message = edit_message;
d71b8ba7 1098 if (amend && !use_message && !fixup_message)
f5bbc322 1099 use_message = "HEAD";
37f7a857 1100 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
8a6179bc 1101 die(_("--reset-author can be used only with -C, -c or --amend."));
f5bbc322 1102 if (use_message) {
37f7a857
JS
1103 use_message_buffer = read_commit_message(use_message);
1104 if (!renew_authorship) {
1105 author_message = use_message;
1106 author_message_buffer = use_message_buffer;
1107 }
1108 }
1109 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1110 author_message = "CHERRY_PICK_HEAD";
1111 author_message_buffer = read_commit_message(author_message);
f5bbc322
KH
1112 }
1113
b4bd4668
CI
1114 if (patch_interactive)
1115 interactive = 1;
1116
05efb7b7 1117 if (also + only + all + interactive > 1)
b4bd4668 1118 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
f5bbc322 1119 if (argc == 0 && (also || (only && !amend)))
8a6179bc 1120 die(_("No paths with --include/--only does not make sense."));
f5bbc322 1121 if (argc == 0 && only && amend)
8a6179bc 1122 only_include_assumed = _("Clever... amending the last one with dirty index.");
3c5283f8 1123 if (argc > 0 && !also && !only)
8a6179bc 1124 only_include_assumed = _("Explicit paths specified without -i nor -o; assuming --only paths...");
5f065737
AR
1125 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1126 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1127 else if (!strcmp(cleanup_arg, "verbatim"))
1128 cleanup_mode = CLEANUP_NONE;
1129 else if (!strcmp(cleanup_arg, "whitespace"))
1130 cleanup_mode = CLEANUP_SPACE;
1131 else if (!strcmp(cleanup_arg, "strip"))
1132 cleanup_mode = CLEANUP_ALL;
1133 else
8a6179bc 1134 die(_("Invalid cleanup mode %s"), cleanup_arg);
f5bbc322 1135
76e2f7ce 1136 handle_untracked_files_arg(s);
4bfee30a 1137
f5bbc322 1138 if (all && argc > 0)
8a6179bc 1139 die(_("Paths with -a does not make sense."));
f5bbc322 1140
f3f47a1e 1141 if (status_format != STATUS_FORMAT_NONE)
7c9f7038
JK
1142 dry_run = 1;
1143
f5bbc322
KH
1144 return argc;
1145}
1146
d249b098 1147static int dry_run_commit(int argc, const char **argv, const char *prefix,
06bb643b 1148 const struct commit *current_head, struct wt_status *s)
f5bbc322 1149{
f5bbc322 1150 int commitable;
3a5d13a3 1151 const char *index_file;
f5bbc322 1152
06bb643b 1153 index_file = prepare_index(argc, argv, prefix, current_head, 1);
d249b098 1154 commitable = run_status(stdout, index_file, prefix, 0, s);
3a5d13a3 1155 rollback_index_files();
f5bbc322 1156
3a5d13a3
JH
1157 return commitable ? 0 : 1;
1158}
1159
f766b367
JH
1160static int parse_status_slot(const char *var, int offset)
1161{
1162 if (!strcasecmp(var+offset, "header"))
1163 return WT_STATUS_HEADER;
1d282327
AA
1164 if (!strcasecmp(var+offset, "branch"))
1165 return WT_STATUS_ONBRANCH;
f766b367
JH
1166 if (!strcasecmp(var+offset, "updated")
1167 || !strcasecmp(var+offset, "added"))
1168 return WT_STATUS_UPDATED;
1169 if (!strcasecmp(var+offset, "changed"))
1170 return WT_STATUS_CHANGED;
1171 if (!strcasecmp(var+offset, "untracked"))
1172 return WT_STATUS_UNTRACKED;
1173 if (!strcasecmp(var+offset, "nobranch"))
1174 return WT_STATUS_NOBRANCH;
1175 if (!strcasecmp(var+offset, "unmerged"))
1176 return WT_STATUS_UNMERGED;
8b8e8624 1177 return -1;
f766b367
JH
1178}
1179
1180static int git_status_config(const char *k, const char *v, void *cb)
1181{
1182 struct wt_status *s = cb;
1183
59556548 1184 if (starts_with(k, "column."))
4d2292e9 1185 return git_column_config(k, v, "status", &s->colopts);
f766b367
JH
1186 if (!strcmp(k, "status.submodulesummary")) {
1187 int is_bool;
1188 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1189 if (is_bool && s->submodule_summary)
1190 s->submodule_summary = -1;
1191 return 0;
1192 }
4fb5166a
JJGG
1193 if (!strcmp(k, "status.short")) {
1194 if (git_config_bool(k, v))
84b4202d 1195 status_deferred_config.status_format = STATUS_FORMAT_SHORT;
4fb5166a 1196 else
84b4202d 1197 status_deferred_config.status_format = STATUS_FORMAT_NONE;
4fb5166a
JJGG
1198 return 0;
1199 }
ec85d070 1200 if (!strcmp(k, "status.branch")) {
84b4202d 1201 status_deferred_config.show_branch = git_config_bool(k, v);
ec85d070
JJGG
1202 return 0;
1203 }
f766b367 1204 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
e269eb79 1205 s->use_color = git_config_colorbool(k, v);
f766b367
JH
1206 return 0;
1207 }
2556b996
MM
1208 if (!strcmp(k, "status.displaycommentprefix")) {
1209 s->display_comment_prefix = git_config_bool(k, v);
1210 return 0;
1211 }
59556548 1212 if (starts_with(k, "status.color.") || starts_with(k, "color.status.")) {
f766b367 1213 int slot = parse_status_slot(k, 13);
8b8e8624
JK
1214 if (slot < 0)
1215 return 0;
f766b367
JH
1216 if (!v)
1217 return config_error_nonbool(k);
1218 color_parse(v, k, s->color_palette[slot]);
1219 return 0;
1220 }
1221 if (!strcmp(k, "status.relativepaths")) {
1222 s->relative_paths = git_config_bool(k, v);
1223 return 0;
1224 }
1225 if (!strcmp(k, "status.showuntrackedfiles")) {
1226 if (!v)
1227 return config_error_nonbool(k);
1228 else if (!strcmp(v, "no"))
1229 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1230 else if (!strcmp(v, "normal"))
1231 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1232 else if (!strcmp(v, "all"))
1233 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1234 else
8a6179bc 1235 return error(_("Invalid untracked files mode '%s'"), v);
f766b367
JH
1236 return 0;
1237 }
1238 return git_diff_ui_config(k, v, NULL);
1239}
1240
3a5d13a3
JH
1241int cmd_status(int argc, const char **argv, const char *prefix)
1242{
036dbbfb 1243 static struct wt_status s;
4bb6644d 1244 int fd;
76e2f7ce 1245 unsigned char sha1[20];
9e4b7ab6 1246 static struct option builtin_status_options[] = {
f2276316 1247 OPT__VERBOSE(&verbose, N_("be verbose")),
dd2be243 1248 OPT_SET_INT('s', "short", &status_format,
f2276316 1249 N_("show status concisely"), STATUS_FORMAT_SHORT),
84b4202d
JH
1250 OPT_BOOL('b', "branch", &s.show_branch,
1251 N_("show branch information")),
6f157871 1252 OPT_SET_INT(0, "porcelain", &status_format,
f2276316 1253 N_("machine-readable output"),
6f157871 1254 STATUS_FORMAT_PORCELAIN),
f3f47a1e
JK
1255 OPT_SET_INT(0, "long", &status_format,
1256 N_("show status in long format (default)"),
1257 STATUS_FORMAT_LONG),
d5d09d47
SB
1258 OPT_BOOL('z', "null", &s.null_termination,
1259 N_("terminate entries with NUL")),
76e2f7ce 1260 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
f2276316
NTND
1261 N_("mode"),
1262 N_("show untracked files, optional modes: all, normal, no. (Default: all)"),
76e2f7ce 1263 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
d5d09d47
SB
1264 OPT_BOOL(0, "ignored", &show_ignored_in_status,
1265 N_("show ignored files")),
f2276316
NTND
1266 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when"),
1267 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"),
46a958b3 1268 PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
9c23f4c5 1269 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
76e2f7ce
JH
1270 OPT_END(),
1271 };
1272
5d3dd915
NTND
1273 if (argc == 2 && !strcmp(argv[1], "-h"))
1274 usage_with_options(builtin_status_usage, builtin_status_options);
1275
5c25dfaa 1276 status_init_config(&s, git_status_config);
76e2f7ce 1277 argc = parse_options(argc, argv, prefix,
9e4b7ab6
JH
1278 builtin_status_options,
1279 builtin_status_usage, 0);
4d2292e9 1280 finalize_colopts(&s.colopts, -1);
84b4202d 1281 finalize_deferred_config(&s);
000f97bd 1282
76e2f7ce 1283 handle_untracked_files_arg(&s);
2381e39e
JH
1284 if (show_ignored_in_status)
1285 s.show_ignored_files = 1;
15b55ae0
NTND
1286 parse_pathspec(&s.pathspec, 0,
1287 PATHSPEC_PREFER_FULL,
1288 prefix, argv);
76e2f7ce 1289
5ab2a2da 1290 read_cache_preload(&s.pathspec);
9b2d6149 1291 refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, &s.pathspec, NULL, NULL);
4bb6644d
MH
1292
1293 fd = hold_locked_index(&index_lock, 0);
ccdc4ec3
JH
1294 if (0 <= fd)
1295 update_index_if_able(&the_index, &index_lock);
4bb6644d 1296
76e2f7ce 1297 s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
46a958b3 1298 s.ignore_submodule_arg = ignore_submodule_arg;
76e2f7ce
JH
1299 wt_status_collect(&s);
1300
8661768f
JK
1301 if (s.relative_paths)
1302 s.prefix = prefix;
38920dd6 1303
dd2be243
JK
1304 switch (status_format) {
1305 case STATUS_FORMAT_SHORT:
d4a6bf1f 1306 wt_shortstatus_print(&s);
dd2be243 1307 break;
6f157871 1308 case STATUS_FORMAT_PORCELAIN:
3207a3a2 1309 wt_porcelain_print(&s);
6f157871 1310 break;
84b4202d
JH
1311 case STATUS_FORMAT_UNSPECIFIED:
1312 die("BUG: finalize_deferred_config() should have been called");
1313 break;
f3f47a1e 1314 case STATUS_FORMAT_NONE:
dd2be243 1315 case STATUS_FORMAT_LONG:
173e6c88 1316 s.verbose = verbose;
46a958b3 1317 s.ignore_submodule_arg = ignore_submodule_arg;
173e6c88 1318 wt_status_print(&s);
dd2be243 1319 break;
173e6c88 1320 }
76e2f7ce 1321 return 0;
f5bbc322
KH
1322}
1323
06bb643b
JH
1324static void print_summary(const char *prefix, const unsigned char *sha1,
1325 int initial_commit)
f5bbc322
KH
1326{
1327 struct rev_info rev;
1328 struct commit *commit;
49ff9a7a 1329 struct strbuf format = STRBUF_INIT;
c85db254 1330 unsigned char junk_sha1[20];
d5a35c11 1331 const char *head;
49ff9a7a
JK
1332 struct pretty_print_context pctx = {0};
1333 struct strbuf author_ident = STRBUF_INIT;
1334 struct strbuf committer_ident = STRBUF_INIT;
f5bbc322
KH
1335
1336 commit = lookup_commit(sha1);
1337 if (!commit)
8a6179bc 1338 die(_("couldn't look up newly created commit"));
5e7d4d3e 1339 if (parse_commit(commit))
8a6179bc 1340 die(_("could not parse newly created commit"));
f5bbc322 1341
49ff9a7a
JK
1342 strbuf_addstr(&format, "format:%h] %s");
1343
1344 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1345 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1346 if (strbuf_cmp(&author_ident, &committer_ident)) {
1347 strbuf_addstr(&format, "\n Author: ");
1348 strbuf_addbuf_percentquote(&format, &author_ident);
1349 }
d6991cee 1350 if (!committer_ident_sufficiently_given()) {
49ff9a7a
JK
1351 strbuf_addstr(&format, "\n Committer: ");
1352 strbuf_addbuf_percentquote(&format, &committer_ident);
b706fcfe
JK
1353 if (advice_implicit_identity) {
1354 strbuf_addch(&format, '\n');
fc88e316 1355 strbuf_addstr(&format, _(implicit_ident_advice));
b706fcfe 1356 }
49ff9a7a
JK
1357 }
1358 strbuf_release(&author_ident);
1359 strbuf_release(&committer_ident);
1360
f5bbc322
KH
1361 init_revisions(&rev, prefix);
1362 setup_revisions(0, NULL, &rev, NULL);
1363
f5bbc322
KH
1364 rev.diff = 1;
1365 rev.diffopt.output_format =
1366 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1367
1368 rev.verbose_header = 1;
1369 rev.show_root_diff = 1;
49ff9a7a 1370 get_commit_format(format.buf, &rev);
bf82a150 1371 rev.always_show_header = 0;
3eb2a15e 1372 rev.diffopt.detect_rename = 1;
3eb2a15e 1373 rev.diffopt.break_opt = 0;
15964563 1374 diff_setup_done(&rev.diffopt);
f5bbc322 1375
8cad4744 1376 head = resolve_ref_unsafe("HEAD", junk_sha1, 0, NULL);
c5ee71fd 1377 printf("[%s%s ",
59556548 1378 starts_with(head, "refs/heads/") ?
c85db254
JK
1379 head + 11 :
1380 !strcmp(head, "HEAD") ?
7f5673d7 1381 _("detached HEAD") :
c85db254 1382 head,
7f5673d7 1383 initial_commit ? _(" (root-commit)") : "");
f5bbc322 1384
bf82a150 1385 if (!log_tree_commit(&rev, commit)) {
a45e1a87
TRC
1386 rev.always_show_header = 1;
1387 rev.use_terminator = 1;
1388 log_tree_commit(&rev, commit);
bf82a150 1389 }
a45e1a87 1390
fc6f19fe 1391 strbuf_release(&format);
f5bbc322
KH
1392}
1393
186458b1 1394static int git_commit_config(const char *k, const char *v, void *cb)
f5bbc322 1395{
d249b098 1396 struct wt_status *s = cb;
ba3c69a9 1397 int status;
d249b098 1398
984c6e7e 1399 if (!strcmp(k, "commit.template"))
395de250 1400 return git_config_pathname(&template_file, k, v);
bed575e4
JHI
1401 if (!strcmp(k, "commit.status")) {
1402 include_status = git_config_bool(k, v);
1403 return 0;
1404 }
51fb3a3d
RT
1405 if (!strcmp(k, "commit.cleanup"))
1406 return git_config_string(&cleanup_arg, k, v);
f5bbc322 1407
ba3c69a9
JH
1408 status = git_gpg_config(k, v, NULL);
1409 if (status)
1410 return status;
d249b098 1411 return git_status_config(k, v, s);
f5bbc322
KH
1412}
1413
6f6bee3b
TR
1414static int run_rewrite_hook(const unsigned char *oldsha1,
1415 const unsigned char *newsha1)
1416{
1417 /* oldsha1 SP newsha1 LF NUL */
1418 static char buf[2*40 + 3];
1419 struct child_process proc;
1420 const char *argv[3];
1421 int code;
1422 size_t n;
1423
5a7da2dc
AS
1424 argv[0] = find_hook("post-rewrite");
1425 if (!argv[0])
6f6bee3b
TR
1426 return 0;
1427
6f6bee3b
TR
1428 argv[1] = "amend";
1429 argv[2] = NULL;
1430
1431 memset(&proc, 0, sizeof(proc));
1432 proc.argv = argv;
1433 proc.in = -1;
1434 proc.stdout_to_stderr = 1;
1435
1436 code = start_command(&proc);
1437 if (code)
1438 return code;
1439 n = snprintf(buf, sizeof(buf), "%s %s\n",
1440 sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1441 write_in_full(proc.in, buf, n);
1442 close(proc.in);
1443 return finish_command(&proc);
1444}
1445
15048f8a
BP
1446int run_commit_hook(int editor_is_used, const char *index_file, const char *name, ...)
1447{
1448 const char *hook_env[3] = { NULL };
1449 char index[PATH_MAX];
1450 va_list args;
1451 int ret;
1452
1453 snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
1454 hook_env[0] = index;
1455
1456 /*
1457 * Let the hook know that no editor will be launched.
1458 */
1459 if (!editor_is_used)
1460 hook_env[1] = "GIT_EDITOR=:";
1461
1462 va_start(args, name);
1463 ret = run_hook_ve(hook_env, name, args);
1464 va_end(args);
1465
1466 return ret;
1467}
1468
f5bbc322
KH
1469int cmd_commit(int argc, const char **argv, const char *prefix)
1470{
036dbbfb
JK
1471 static struct wt_status s;
1472 static struct option builtin_commit_options[] = {
9c23f4c5
NTND
1473 OPT__QUIET(&quiet, N_("suppress summary after successful commit")),
1474 OPT__VERBOSE(&verbose, N_("show diff in commit message template")),
1475
1476 OPT_GROUP(N_("Commit message options")),
1477 OPT_FILENAME('F', "file", &logfile, N_("read message from file")),
1478 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")),
1479 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")),
1480 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m),
1481 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")),
1482 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")),
1483 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")),
1484 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")),
d5d09d47
SB
1485 OPT_BOOL(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")),
1486 OPT_BOOL('s', "signoff", &signoff, N_("add Signed-off-by:")),
9c23f4c5
NTND
1487 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")),
1488 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")),
1489 OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")),
d5d09d47 1490 OPT_BOOL(0, "status", &include_status, N_("include status in commit message template")),
9c23f4c5
NTND
1491 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key id"),
1492 N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
036dbbfb
JK
1493 /* end commit message options */
1494
9c23f4c5 1495 OPT_GROUP(N_("Commit contents options")),
d5d09d47
SB
1496 OPT_BOOL('a', "all", &all, N_("commit all changed files")),
1497 OPT_BOOL('i', "include", &also, N_("add specified files to index for commit")),
1498 OPT_BOOL(0, "interactive", &interactive, N_("interactively add files")),
1499 OPT_BOOL('p', "patch", &patch_interactive, N_("interactively add changes")),
1500 OPT_BOOL('o', "only", &only, N_("commit only specified files")),
1501 OPT_BOOL('n', "no-verify", &no_verify, N_("bypass pre-commit hook")),
1502 OPT_BOOL(0, "dry-run", &dry_run, N_("show what would be committed")),
9c23f4c5 1503 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),
036dbbfb 1504 STATUS_FORMAT_SHORT),
84b4202d 1505 OPT_BOOL(0, "branch", &s.show_branch, N_("show branch information")),
036dbbfb 1506 OPT_SET_INT(0, "porcelain", &status_format,
9c23f4c5 1507 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN),
f3f47a1e
JK
1508 OPT_SET_INT(0, "long", &status_format,
1509 N_("show status in long format (default)"),
1510 STATUS_FORMAT_LONG),
d5d09d47
SB
1511 OPT_BOOL('z', "null", &s.null_termination,
1512 N_("terminate entries with NUL")),
1513 OPT_BOOL(0, "amend", &amend, N_("amend previous commit")),
1514 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")),
9c23f4c5 1515 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg, N_("mode"), N_("show untracked files, optional modes: all, normal, no. (Default: all)"), PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
036dbbfb
JK
1516 /* end commit contents options */
1517
4741edd5
SB
1518 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty,
1519 N_("ok to record an empty change")),
1520 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message,
1521 N_("ok to record a change with an empty message")),
036dbbfb
JK
1522
1523 OPT_END()
1524 };
1525
f285a2d7 1526 struct strbuf sb = STRBUF_INIT;
4c28e4ad 1527 struct strbuf author_ident = STRBUF_INIT;
f5bbc322 1528 const char *index_file, *reflog_msg;
1a72cfd7 1529 char *nl;
06bb643b 1530 unsigned char sha1[20];
f5bbc322 1531 struct ref_lock *ref_lock;
6bb6b034 1532 struct commit_list *parents = NULL, **pptr = &parents;
cf10f9fd
MV
1533 struct stat statbuf;
1534 int allow_fast_forward = 1;
06bb643b 1535 struct commit *current_head = NULL;
ed7a42a0 1536 struct commit_extra_header *extra = NULL;
f5bbc322 1537
5d3dd915
NTND
1538 if (argc == 2 && !strcmp(argv[1], "-h"))
1539 usage_with_options(builtin_commit_usage, builtin_commit_options);
1540
5c25dfaa 1541 status_init_config(&s, git_commit_config);
f0915cba 1542 status_format = STATUS_FORMAT_NONE; /* Ignore status.short */
4d2292e9 1543 s.colopts = 0;
f5bbc322 1544
06bb643b
JH
1545 if (get_sha1("HEAD", sha1))
1546 current_head = NULL;
1547 else {
baf18fc2 1548 current_head = lookup_commit_or_die(sha1, "HEAD");
5e7d4d3e 1549 if (parse_commit(current_head))
06bb643b
JH
1550 die(_("could not parse HEAD commit"));
1551 }
036dbbfb
JK
1552 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1553 builtin_commit_usage,
06bb643b 1554 prefix, current_head, &s);
c9bfb953 1555 if (dry_run)
06bb643b 1556 return dry_run_commit(argc, argv, prefix, current_head, &s);
06bb643b 1557 index_file = prepare_index(argc, argv, prefix, current_head, 0);
f5bbc322 1558
ec84bd00
PB
1559 /* Set up everything for writing the commit object. This includes
1560 running hooks, writing the trees, and interacting with the user. */
06bb643b
JH
1561 if (!prepare_to_commit(index_file, prefix,
1562 current_head, &s, &author_ident)) {
2888605c 1563 rollback_index_files();
f5bbc322
KH
1564 return 1;
1565 }
1566
f5bbc322 1567 /* Determine parents */
643cb5f7 1568 reflog_msg = getenv("GIT_REFLOG_ACTION");
06bb643b 1569 if (!current_head) {
643cb5f7
CC
1570 if (!reflog_msg)
1571 reflog_msg = "commit (initial)";
f5bbc322
KH
1572 } else if (amend) {
1573 struct commit_list *c;
f5bbc322 1574
643cb5f7
CC
1575 if (!reflog_msg)
1576 reflog_msg = "commit (amend)";
06bb643b 1577 for (c = current_head->parents; c; c = c->next)
6bb6b034 1578 pptr = &commit_list_insert(c->item, pptr)->next;
37f7a857 1579 } else if (whence == FROM_MERGE) {
f285a2d7 1580 struct strbuf m = STRBUF_INIT;
f5bbc322
KH
1581 FILE *fp;
1582
643cb5f7
CC
1583 if (!reflog_msg)
1584 reflog_msg = "commit (merge)";
06bb643b 1585 pptr = &commit_list_insert(current_head, pptr)->next;
f5bbc322
KH
1586 fp = fopen(git_path("MERGE_HEAD"), "r");
1587 if (fp == NULL)
8a6179bc 1588 die_errno(_("could not open '%s' for reading"),
d824cbba 1589 git_path("MERGE_HEAD"));
7c3fd25d 1590 while (strbuf_getline(&m, fp, '\n') != EOF) {
5231c633
JH
1591 struct commit *parent;
1592
1593 parent = get_merge_parent(m.buf);
1594 if (!parent)
8a6179bc 1595 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
5231c633 1596 pptr = &commit_list_insert(parent, pptr)->next;
7c3fd25d 1597 }
f5bbc322
KH
1598 fclose(fp);
1599 strbuf_release(&m);
cf10f9fd
MV
1600 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1601 if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
8a6179bc 1602 die_errno(_("could not read MERGE_MODE"));
cf10f9fd
MV
1603 if (!strcmp(sb.buf, "no-ff"))
1604 allow_fast_forward = 0;
1605 }
1606 if (allow_fast_forward)
1607 parents = reduce_heads(parents);
f5bbc322 1608 } else {
643cb5f7 1609 if (!reflog_msg)
37f7a857
JS
1610 reflog_msg = (whence == FROM_CHERRY_PICK)
1611 ? "commit (cherry-pick)"
1612 : "commit";
06bb643b 1613 pptr = &commit_list_insert(current_head, pptr)->next;
f5bbc322 1614 }
f5bbc322 1615
ec84bd00 1616 /* Finally, get the commit message */
cf10f9fd 1617 strbuf_reset(&sb);
740001a5 1618 if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
0721c314 1619 int saved_errno = errno;
740001a5 1620 rollback_index_files();
8a6179bc 1621 die(_("could not read commit message: %s"), strerror(saved_errno));
740001a5 1622 }
99a12694
KH
1623
1624 /* Truncate the message just before the diff, if any. */
1a72cfd7
JL
1625 if (verbose)
1626 wt_status_truncate_message_at_cut_line(&sb);
99a12694 1627
5f065737
AR
1628 if (cleanup_mode != CLEANUP_NONE)
1629 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
b2eda9bd
JH
1630 if (template_untouched(&sb) && !allow_empty_message) {
1631 rollback_index_files();
1632 fprintf(stderr, _("Aborting commit; you did not edit the message.\n"));
1633 exit(1);
1634 }
c9b5fde7 1635 if (message_is_empty(&sb) && !allow_empty_message) {
2888605c 1636 rollback_index_files();
8a6179bc 1637 fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
fdc7c811 1638 exit(1);
2888605c 1639 }
f5bbc322 1640
0074d18d 1641 if (amend) {
c871a1d1
JH
1642 const char *exclude_gpgsig[2] = { "gpgsig", NULL };
1643 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
0074d18d
JH
1644 } else {
1645 struct commit_extra_header **tail = &extra;
1646 append_merge_tag_headers(parents, &tail);
1647 }
ed7a42a0 1648
f35ccd9b 1649 if (commit_tree_extended(&sb, active_cache_tree->sha1, parents, sha1,
ba3c69a9 1650 author_ident.buf, sign_commit, extra)) {
2888605c 1651 rollback_index_files();
8a6179bc 1652 die(_("failed to write commit object"));
2888605c 1653 }
4c28e4ad 1654 strbuf_release(&author_ident);
ed7a42a0 1655 free_commit_extra_headers(extra);
f5bbc322
KH
1656
1657 ref_lock = lock_any_ref_for_update("HEAD",
06bb643b
JH
1658 !current_head
1659 ? NULL
1660 : current_head->object.sha1,
9bbb0fa1 1661 0, NULL);
f5bbc322 1662
6bb6b034 1663 nl = strchr(sb.buf, '\n');
741707b1
JS
1664 if (nl)
1665 strbuf_setlen(&sb, nl + 1 - sb.buf);
1666 else
1667 strbuf_addch(&sb, '\n');
741707b1
JS
1668 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1669 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
f5bbc322 1670
2888605c
JH
1671 if (!ref_lock) {
1672 rollback_index_files();
8a6179bc 1673 die(_("cannot lock HEAD ref"));
2888605c 1674 }
06bb643b 1675 if (write_ref_sha1(ref_lock, sha1, sb.buf) < 0) {
2888605c 1676 rollback_index_files();
8a6179bc 1677 die(_("cannot update HEAD ref"));
2888605c 1678 }
f5bbc322 1679
d7e5c0cb 1680 unlink(git_path("CHERRY_PICK_HEAD"));
82433cdf 1681 unlink(git_path("REVERT_HEAD"));
f5bbc322
KH
1682 unlink(git_path("MERGE_HEAD"));
1683 unlink(git_path("MERGE_MSG"));
cf10f9fd 1684 unlink(git_path("MERGE_MODE"));
5a95b855 1685 unlink(git_path("SQUASH_MSG"));
f5bbc322 1686
5a9dd399 1687 if (commit_index_files())
8a6179bc 1688 die (_("Repository has been updated, but unable to write\n"
5a9dd399 1689 "new_index file. Check that disk is not full or quota is\n"
8a6179bc 1690 "not exceeded, and then \"git reset HEAD\" to recover."));
f5bbc322 1691
cb6020bb 1692 rerere(0);
15048f8a 1693 run_commit_hook(use_editor, get_index_file(), "post-commit", NULL);
6f6bee3b 1694 if (amend && !no_post_rewrite) {
6360d343
TR
1695 struct notes_rewrite_cfg *cfg;
1696 cfg = init_copy_notes_for_rewrite("amend");
1697 if (cfg) {
06bb643b
JH
1698 /* we are amending, so current_head is not NULL */
1699 copy_note_for_rewrite(cfg, current_head->object.sha1, sha1);
80a14665 1700 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
6360d343 1701 }
06bb643b 1702 run_rewrite_hook(current_head->object.sha1, sha1);
6f6bee3b 1703 }
f5bbc322 1704 if (!quiet)
06bb643b 1705 print_summary(prefix, sha1, !current_head);
f5bbc322
KH
1706
1707 return 0;
1708}