builtin/commit.c

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