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