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