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