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                 update_index_if_able(&the_index, &index_lock);
1095
1096         s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1097         s.in_merge = in_merge;
1098         s.ignore_submodule_arg = ignore_submodule_arg;
1099         wt_status_collect(&s);
1100
1101         if (s.relative_paths)
1102                 s.prefix = prefix;
1103         if (s.use_color == -1)
1104                 s.use_color = git_use_color_default;
1105         if (diff_use_color_default == -1)
1106                 diff_use_color_default = git_use_color_default;
1107
1108         switch (status_format) {
1109         case STATUS_FORMAT_SHORT:
1110                 wt_shortstatus_print(&s, null_termination, status_show_branch);
1111                 break;
1112         case STATUS_FORMAT_PORCELAIN:
1113                 wt_porcelain_print(&s, null_termination);
1114                 break;
1115         case STATUS_FORMAT_LONG:
1116                 s.verbose = verbose;
1117                 s.ignore_submodule_arg = ignore_submodule_arg;
1118                 wt_status_print(&s);
1119                 break;
1120         }
1121         return 0;
1122 }
1123
1124 static void print_summary(const char *prefix, const unsigned char *sha1)
1125 {
1126         struct rev_info rev;
1127         struct commit *commit;
1128         struct strbuf format = STRBUF_INIT;
1129         unsigned char junk_sha1[20];
1130         const char *head = resolve_ref("HEAD", junk_sha1, 0, NULL);
1131         struct pretty_print_context pctx = {0};
1132         struct strbuf author_ident = STRBUF_INIT;
1133         struct strbuf committer_ident = STRBUF_INIT;
1134
1135         commit = lookup_commit(sha1);
1136         if (!commit)
1137                 die("couldn't look up newly created commit");
1138         if (!commit || parse_commit(commit))
1139                 die("could not parse newly created commit");
1140
1141         strbuf_addstr(&format, "format:%h] %s");
1142
1143         format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1144         format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1145         if (strbuf_cmp(&author_ident, &committer_ident)) {
1146                 strbuf_addstr(&format, "\n Author: ");
1147                 strbuf_addbuf_percentquote(&format, &author_ident);
1148         }
1149         if (!user_ident_sufficiently_given()) {
1150                 strbuf_addstr(&format, "\n Committer: ");
1151                 strbuf_addbuf_percentquote(&format, &committer_ident);
1152                 if (advice_implicit_identity) {
1153                         strbuf_addch(&format, '\n');
1154                         strbuf_addstr(&format, implicit_ident_advice);
1155                 }
1156         }
1157         strbuf_release(&author_ident);
1158         strbuf_release(&committer_ident);
1159
1160         init_revisions(&rev, prefix);
1161         setup_revisions(0, NULL, &rev, NULL);
1162
1163         rev.diff = 1;
1164         rev.diffopt.output_format =
1165                 DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
1166
1167         rev.verbose_header = 1;
1168         rev.show_root_diff = 1;
1169         get_commit_format(format.buf, &rev);
1170         rev.always_show_header = 0;
1171         rev.diffopt.detect_rename = 1;
1172         rev.diffopt.rename_limit = 100;
1173         rev.diffopt.break_opt = 0;
1174         diff_setup_done(&rev.diffopt);
1175
1176         printf("[%s%s ",
1177                 !prefixcmp(head, "refs/heads/") ?
1178                         head + 11 :
1179                         !strcmp(head, "HEAD") ?
1180                                 "detached HEAD" :
1181                                 head,
1182                 initial_commit ? " (root-commit)" : "");
1183
1184         if (!log_tree_commit(&rev, commit)) {
1185                 rev.always_show_header = 1;
1186                 rev.use_terminator = 1;
1187                 log_tree_commit(&rev, commit);
1188         }
1189
1190         strbuf_release(&format);
1191 }
1192
1193 static int git_commit_config(const char *k, const char *v, void *cb)
1194 {
1195         struct wt_status *s = cb;
1196
1197         if (!strcmp(k, "commit.template"))
1198                 return git_config_pathname(&template_file, k, v);
1199         if (!strcmp(k, "commit.status")) {
1200                 include_status = git_config_bool(k, v);
1201                 return 0;
1202         }
1203
1204         return git_status_config(k, v, s);
1205 }
1206
1207 static const char post_rewrite_hook[] = "hooks/post-rewrite";
1208
1209 static int run_rewrite_hook(const unsigned char *oldsha1,
1210                             const unsigned char *newsha1)
1211 {
1212         /* oldsha1 SP newsha1 LF NUL */
1213         static char buf[2*40 + 3];
1214         struct child_process proc;
1215         const char *argv[3];
1216         int code;
1217         size_t n;
1218
1219         if (access(git_path(post_rewrite_hook), X_OK) < 0)
1220                 return 0;
1221
1222         argv[0] = git_path(post_rewrite_hook);
1223         argv[1] = "amend";
1224         argv[2] = NULL;
1225
1226         memset(&proc, 0, sizeof(proc));
1227         proc.argv = argv;
1228         proc.in = -1;
1229         proc.stdout_to_stderr = 1;
1230
1231         code = start_command(&proc);
1232         if (code)
1233                 return code;
1234         n = snprintf(buf, sizeof(buf), "%s %s\n",
1235                      sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1236         write_in_full(proc.in, buf, n);
1237         close(proc.in);
1238         return finish_command(&proc);
1239 }
1240
1241 int cmd_commit(int argc, const char **argv, const char *prefix)
1242 {
1243         struct strbuf sb = STRBUF_INIT;
1244         const char *index_file, *reflog_msg;
1245         char *nl, *p;
1246         unsigned char commit_sha1[20];
1247         struct ref_lock *ref_lock;
1248         struct commit_list *parents = NULL, **pptr = &parents;
1249         struct stat statbuf;
1250         int allow_fast_forward = 1;
1251         struct wt_status s;
1252
1253         wt_status_prepare(&s);
1254         git_config(git_commit_config, &s);
1255         in_merge = file_exists(git_path("MERGE_HEAD"));
1256         s.in_merge = in_merge;
1257
1258         if (s.use_color == -1)
1259                 s.use_color = git_use_color_default;
1260         argc = parse_and_validate_options(argc, argv, builtin_commit_usage,
1261                                           prefix, &s);
1262         if (dry_run) {
1263                 if (diff_use_color_default == -1)
1264                         diff_use_color_default = git_use_color_default;
1265                 return dry_run_commit(argc, argv, prefix, &s);
1266         }
1267         index_file = prepare_index(argc, argv, prefix, 0);
1268
1269         /* Set up everything for writing the commit object.  This includes
1270            running hooks, writing the trees, and interacting with the user.  */
1271         if (!prepare_to_commit(index_file, prefix, &s)) {
1272                 rollback_index_files();
1273                 return 1;
1274         }
1275
1276         /* Determine parents */
1277         reflog_msg = getenv("GIT_REFLOG_ACTION");
1278         if (initial_commit) {
1279                 if (!reflog_msg)
1280                         reflog_msg = "commit (initial)";
1281         } else if (amend) {
1282                 struct commit_list *c;
1283                 struct commit *commit;
1284
1285                 if (!reflog_msg)
1286                         reflog_msg = "commit (amend)";
1287                 commit = lookup_commit(head_sha1);
1288                 if (!commit || parse_commit(commit))
1289                         die("could not parse HEAD commit");
1290
1291                 for (c = commit->parents; c; c = c->next)
1292                         pptr = &commit_list_insert(c->item, pptr)->next;
1293         } else if (in_merge) {
1294                 struct strbuf m = STRBUF_INIT;
1295                 FILE *fp;
1296
1297                 if (!reflog_msg)
1298                         reflog_msg = "commit (merge)";
1299                 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1300                 fp = fopen(git_path("MERGE_HEAD"), "r");
1301                 if (fp == NULL)
1302                         die_errno("could not open '%s' for reading",
1303                                   git_path("MERGE_HEAD"));
1304                 while (strbuf_getline(&m, fp, '\n') != EOF) {
1305                         unsigned char sha1[20];
1306                         if (get_sha1_hex(m.buf, sha1) < 0)
1307                                 die("Corrupt MERGE_HEAD file (%s)", m.buf);
1308                         pptr = &commit_list_insert(lookup_commit(sha1), pptr)->next;
1309                 }
1310                 fclose(fp);
1311                 strbuf_release(&m);
1312                 if (!stat(git_path("MERGE_MODE"), &statbuf)) {
1313                         if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
1314                                 die_errno("could not read MERGE_MODE");
1315                         if (!strcmp(sb.buf, "no-ff"))
1316                                 allow_fast_forward = 0;
1317                 }
1318                 if (allow_fast_forward)
1319                         parents = reduce_heads(parents);
1320         } else {
1321                 if (!reflog_msg)
1322                         reflog_msg = "commit";
1323                 pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
1324         }
1325
1326         /* Finally, get the commit message */
1327         strbuf_reset(&sb);
1328         if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
1329                 int saved_errno = errno;
1330                 rollback_index_files();
1331                 die("could not read commit message: %s", strerror(saved_errno));
1332         }
1333
1334         /* Truncate the message just before the diff, if any. */
1335         if (verbose) {
1336                 p = strstr(sb.buf, "\ndiff --git ");
1337                 if (p != NULL)
1338                         strbuf_setlen(&sb, p - sb.buf + 1);
1339         }
1340
1341         if (cleanup_mode != CLEANUP_NONE)
1342                 stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1343         if (message_is_empty(&sb) && !allow_empty_message) {
1344                 rollback_index_files();
1345                 fprintf(stderr, "Aborting commit due to empty commit message.\n");
1346                 exit(1);
1347         }
1348
1349         if (commit_tree(sb.buf, active_cache_tree->sha1, parents, commit_sha1,
1350                         fmt_ident(author_name, author_email, author_date,
1351                                 IDENT_ERROR_ON_NO_NAME))) {
1352                 rollback_index_files();
1353                 die("failed to write commit object");
1354         }
1355
1356         ref_lock = lock_any_ref_for_update("HEAD",
1357                                            initial_commit ? NULL : head_sha1,
1358                                            0);
1359
1360         nl = strchr(sb.buf, '\n');
1361         if (nl)
1362                 strbuf_setlen(&sb, nl + 1 - sb.buf);
1363         else
1364                 strbuf_addch(&sb, '\n');
1365         strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1366         strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1367
1368         if (!ref_lock) {
1369                 rollback_index_files();
1370                 die("cannot lock HEAD ref");
1371         }
1372         if (write_ref_sha1(ref_lock, commit_sha1, sb.buf) < 0) {
1373                 rollback_index_files();
1374                 die("cannot update HEAD ref");
1375         }
1376
1377         unlink(git_path("MERGE_HEAD"));
1378         unlink(git_path("MERGE_MSG"));
1379         unlink(git_path("MERGE_MODE"));
1380         unlink(git_path("SQUASH_MSG"));
1381
1382         if (commit_index_files())
1383                 die ("Repository has been updated, but unable to write\n"
1384                      "new_index file. Check that disk is not full or quota is\n"
1385                      "not exceeded, and then \"git reset HEAD\" to recover.");
1386
1387         rerere(0);
1388         run_hook(get_index_file(), "post-commit", NULL);
1389         if (amend && !no_post_rewrite) {
1390                 struct notes_rewrite_cfg *cfg;
1391                 cfg = init_copy_notes_for_rewrite("amend");
1392                 if (cfg) {
1393                         copy_note_for_rewrite(cfg, head_sha1, commit_sha1);
1394                         finish_copy_notes_for_rewrite(cfg);
1395                 }
1396                 run_rewrite_hook(head_sha1, commit_sha1);
1397         }
1398         if (!quiet)
1399                 print_summary(prefix, commit_sha1);
1400
1401         return 0;
1402 }