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