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