builtin/commit.c

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