git.oblomov.eu Git - git/blob - builtin-commit.c

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