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