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