Bug Summary

File:builtin/commit.c
Location:line 1367, column 2
Description:Value stored to 'argc' is never read

Annotated Source Code

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 "lockfile.h"
10#include "cache-tree.h"
11#include "color.h"
12#include "dir.h"
13#include "builtin.h"
14#include "diff.h"
15#include "diffcore.h"
16#include "commit.h"
17#include "revision.h"
18#include "wt-status.h"
19#include "run-command.h"
20#include "refs.h"
21#include "log-tree.h"
22#include "strbuf.h"
23#include "utf8.h"
24#include "parse-options.h"
25#include "string-list.h"
26#include "rerere.h"
27#include "unpack-trees.h"
28#include "quote.h"
29#include "submodule.h"
30#include "gpg-interface.h"
31#include "column.h"
32#include "sequencer.h"
33#include "notes-utils.h"
34#include "mailmap.h"
35#include "sigchain.h"
36
37static const char * const builtin_commit_usage[] = {
38 N_("git commit [<options>] [--] <pathspec>...")("git commit [<options>] [--] <pathspec>..."),
39 NULL((void*)0)
40};
41
42static const char * const builtin_status_usage[] = {
43 N_("git status [<options>] [--] <pathspec>...")("git status [<options>] [--] <pathspec>..."),
44 NULL((void*)0)
45};
46
47static const char implicit_ident_advice_noconfig[] =
48N_("Your name and email address were configured automatically based\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly. Run the\n"
"following command and follow the instructions in your editor to edit\n"
"your configuration file:\n""\n"" git config --global --edit\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
49"on your username and hostname. Please check that they are accurate.\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly. Run the\n"
"following command and follow the instructions in your editor to edit\n"
"your configuration file:\n""\n"" git config --global --edit\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
50"You can suppress this message by setting them explicitly. Run the\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly. Run the\n"
"following command and follow the instructions in your editor to edit\n"
"your configuration file:\n""\n"" git config --global --edit\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
51"following command and follow the instructions in your editor to edit\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly. Run the\n"
"following command and follow the instructions in your editor to edit\n"
"your configuration file:\n""\n"" git config --global --edit\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
52"your configuration file:\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly. Run the\n"
"following command and follow the instructions in your editor to edit\n"
"your configuration file:\n""\n"" git config --global --edit\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
53"\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly. Run the\n"
"following command and follow the instructions in your editor to edit\n"
"your configuration file:\n""\n"" git config --global --edit\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
54" git config --global --edit\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly. Run the\n"
"following command and follow the instructions in your editor to edit\n"
"your configuration file:\n""\n"" git config --global --edit\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
55"\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly. Run the\n"
"following command and follow the instructions in your editor to edit\n"
"your configuration file:\n""\n"" git config --global --edit\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
56"After doing this, you may fix the identity used for this commit with:\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly. Run the\n"
"following command and follow the instructions in your editor to edit\n"
"your configuration file:\n""\n"" git config --global --edit\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
57"\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly. Run the\n"
"following command and follow the instructions in your editor to edit\n"
"your configuration file:\n""\n"" git config --global --edit\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
58" git commit --amend --reset-author\n")("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly. Run the\n"
"following command and follow the instructions in your editor to edit\n"
"your configuration file:\n""\n"" git config --global --edit\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
;
59
60static const char implicit_ident_advice_config[] =
61N_("Your name and email address were configured automatically based\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly:\n"
"\n"" git config --global user.name \"Your Name\"\n"" git config --global user.email you@example.com\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
62"on your username and hostname. Please check that they are accurate.\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly:\n"
"\n"" git config --global user.name \"Your Name\"\n"" git config --global user.email you@example.com\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
63"You can suppress this message by setting them explicitly:\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly:\n"
"\n"" git config --global user.name \"Your Name\"\n"" git config --global user.email you@example.com\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
64"\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly:\n"
"\n"" git config --global user.name \"Your Name\"\n"" git config --global user.email you@example.com\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
65" git config --global user.name \"Your Name\"\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly:\n"
"\n"" git config --global user.name \"Your Name\"\n"" git config --global user.email you@example.com\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
66" git config --global user.email you@example.com\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly:\n"
"\n"" git config --global user.name \"Your Name\"\n"" git config --global user.email you@example.com\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
67"\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly:\n"
"\n"" git config --global user.name \"Your Name\"\n"" git config --global user.email you@example.com\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
68"After doing this, you may fix the identity used for this commit with:\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly:\n"
"\n"" git config --global user.name \"Your Name\"\n"" git config --global user.email you@example.com\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
69"\n"("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly:\n"
"\n"" git config --global user.name \"Your Name\"\n"" git config --global user.email you@example.com\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
70" git commit --amend --reset-author\n")("Your name and email address were configured automatically based\n"
"on your username and hostname. Please check that they are accurate.\n"
"You can suppress this message by setting them explicitly:\n"
"\n"" git config --global user.name \"Your Name\"\n"" git config --global user.email you@example.com\n"
"\n""After doing this, you may fix the identity used for this commit with:\n"
"\n"" git commit --amend --reset-author\n")
;
71
72static const char empty_amend_advice[] =
73N_("You asked to amend the most recent commit, but doing so would make\n"("You asked to amend the most recent commit, but doing so would make\n"
"it empty. You can repeat your command with --allow-empty, or you can\n"
"remove the commit entirely with \"git reset HEAD^\".\n")
74"it empty. You can repeat your command with --allow-empty, or you can\n"("You asked to amend the most recent commit, but doing so would make\n"
"it empty. You can repeat your command with --allow-empty, or you can\n"
"remove the commit entirely with \"git reset HEAD^\".\n")
75"remove the commit entirely with \"git reset HEAD^\".\n")("You asked to amend the most recent commit, but doing so would make\n"
"it empty. You can repeat your command with --allow-empty, or you can\n"
"remove the commit entirely with \"git reset HEAD^\".\n")
;
76
77static const char empty_cherry_pick_advice[] =
78N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
"If you wish to commit it anyway, use:\n""\n"" git commit --allow-empty\n"
"\n")
79"If you wish to commit it anyway, use:\n"("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
"If you wish to commit it anyway, use:\n""\n"" git commit --allow-empty\n"
"\n")
80"\n"("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
"If you wish to commit it anyway, use:\n""\n"" git commit --allow-empty\n"
"\n")
81" git commit --allow-empty\n"("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
"If you wish to commit it anyway, use:\n""\n"" git commit --allow-empty\n"
"\n")
82"\n")("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
"If you wish to commit it anyway, use:\n""\n"" git commit --allow-empty\n"
"\n")
;
83
84static const char empty_cherry_pick_advice_single[] =
85N_("Otherwise, please use 'git reset'\n")("Otherwise, please use 'git reset'\n");
86
87static const char empty_cherry_pick_advice_multi[] =
88N_("If you wish to skip this commit, use:\n"("If you wish to skip this commit, use:\n""\n"" git reset\n"
"\n""Then \"git cherry-pick --continue\" will resume cherry-picking\n"
"the remaining commits.\n")
89"\n"("If you wish to skip this commit, use:\n""\n"" git reset\n"
"\n""Then \"git cherry-pick --continue\" will resume cherry-picking\n"
"the remaining commits.\n")
90" git reset\n"("If you wish to skip this commit, use:\n""\n"" git reset\n"
"\n""Then \"git cherry-pick --continue\" will resume cherry-picking\n"
"the remaining commits.\n")
91"\n"("If you wish to skip this commit, use:\n""\n"" git reset\n"
"\n""Then \"git cherry-pick --continue\" will resume cherry-picking\n"
"the remaining commits.\n")
92"Then \"git cherry-pick --continue\" will resume cherry-picking\n"("If you wish to skip this commit, use:\n""\n"" git reset\n"
"\n""Then \"git cherry-pick --continue\" will resume cherry-picking\n"
"the remaining commits.\n")
93"the remaining commits.\n")("If you wish to skip this commit, use:\n""\n"" git reset\n"
"\n""Then \"git cherry-pick --continue\" will resume cherry-picking\n"
"the remaining commits.\n")
;
94
95static GIT_PATH_FUNC(git_path_commit_editmsg, "COMMIT_EDITMSG")const char *git_path_commit_editmsg(void) { static char *ret;
if (!ret) ret = git_pathdup("COMMIT_EDITMSG"); return ret; }
96
97static const char *use_message_buffer;
98static struct lock_file index_lock; /* real index */
99static struct lock_file false_lock; /* used only for partial commits */
100static enum {
101 COMMIT_AS_IS = 1,
102 COMMIT_NORMAL,
103 COMMIT_PARTIAL
104} commit_style;
105
106static const char *logfile, *force_author;
107static const char *template_file;
108/*
109 * The _message variables are commit names from which to take
110 * the commit message and/or authorship.
111 */
112static const char *author_message, *author_message_buffer;
113static char *edit_message, *use_message;
114static char *fixup_message, *squash_message;
115static int all, also, interactive, patch_interactive, only, amend, signoff;
116static int edit_flag = -1; /* unspecified */
117static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
118static int config_commit_verbose = -1; /* unspecified */
119static int no_post_rewrite, allow_empty_message;
120static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
121static char *sign_commit;
122
123/*
124 * The default commit message cleanup mode will remove the lines
125 * beginning with # (shell comments) and leading and trailing
126 * whitespaces (empty lines or containing only whitespaces)
127 * if editor is used, and only the whitespaces if the message
128 * is specified explicitly.
129 */
130static enum {
131 CLEANUP_SPACE,
132 CLEANUP_NONE,
133 CLEANUP_SCISSORS,
134 CLEANUP_ALL
135} cleanup_mode;
136static const char *cleanup_arg;
137
138static enum commit_whence whence;
139static int sequencer_in_use;
140static int use_editor = 1, include_status = 1;
141static int show_ignored_in_status, have_option_m;
142static const char *only_include_assumed;
143static struct strbuf message = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
144
145static enum wt_status_format status_format = STATUS_FORMAT_UNSPECIFIED;
146
147static int opt_parse_porcelain(const struct option *opt, const char *arg, int unset)
148{
149 enum wt_status_format *value = (enum wt_status_format *)opt->value;
150 if (unset)
151 *value = STATUS_FORMAT_NONE;
152 else if (!arg)
153 *value = STATUS_FORMAT_PORCELAIN;
154 else if (!strcmp(arg, "v1") || !strcmp(arg, "1"))
155 *value = STATUS_FORMAT_PORCELAIN;
156 else if (!strcmp(arg, "v2") || !strcmp(arg, "2"))
157 *value = STATUS_FORMAT_PORCELAIN_V2;
158 else
159 die("unsupported porcelain version '%s'", arg);
160
161 return 0;
162}
163
164static int opt_parse_m(const struct option *opt, const char *arg, int unset)
165{
166 struct strbuf *buf = opt->value;
167 if (unset) {
168 have_option_m = 0;
169 strbuf_setlen(buf, 0);
170 } else {
171 have_option_m = 1;
172 if (buf->len)
173 strbuf_addch(buf, '\n');
174 strbuf_addstr(buf, arg);
175 strbuf_complete_line(buf);
176 }
177 return 0;
178}
179
180static void determine_whence(struct wt_status *s)
181{
182 if (file_exists(git_path_merge_head()))
183 whence = FROM_MERGE;
184 else if (file_exists(git_path_cherry_pick_head())) {
185 whence = FROM_CHERRY_PICK;
186 if (file_exists(git_path_seq_dir()))
187 sequencer_in_use = 1;
188 }
189 else
190 whence = FROM_COMMIT;
191 if (s)
192 s->whence = whence;
193}
194
195static void status_init_config(struct wt_status *s, config_fn_t fn)
196{
197 wt_status_prepare(s);
198 gitmodules_config();
199 git_config(fn, s);
200 determine_whence(s);
201 init_diff_ui_defaults();
202 s->hints = advice_status_hints; /* must come after git_config() */
203}
204
205static void rollback_index_files(void)
206{
207 switch (commit_style) {
208 case COMMIT_AS_IS:
209 break; /* nothing to do */
210 case COMMIT_NORMAL:
211 rollback_lock_file(&index_lock);
212 break;
213 case COMMIT_PARTIAL:
214 rollback_lock_file(&index_lock);
215 rollback_lock_file(&false_lock);
216 break;
217 }
218}
219
220static int commit_index_files(void)
221{
222 int err = 0;
223
224 switch (commit_style) {
225 case COMMIT_AS_IS:
226 break; /* nothing to do */
227 case COMMIT_NORMAL:
228 err = commit_lock_file(&index_lock);
229 break;
230 case COMMIT_PARTIAL:
231 err = commit_lock_file(&index_lock);
232 rollback_lock_file(&false_lock);
233 break;
234 }
235
236 return err;
237}
238
239/*
240 * Take a union of paths in the index and the named tree (typically, "HEAD"),
241 * and return the paths that match the given pattern in list.
242 */
243static int list_paths(struct string_list *list, const char *with_tree,
244 const char *prefix, const struct pathspec *pattern)
245{
246 int i, ret;
247 char *m;
248
249 if (!pattern->nr)
250 return 0;
251
252 m = xcalloc(1, pattern->nr);
253
254 if (with_tree) {
255 char *max_prefix = common_prefix(pattern);
256 overlay_tree_on_cache(with_tree, max_prefix ? max_prefix : prefix);
257 free(max_prefix);
258 }
259
260 for (i = 0; i < active_nr(the_index.cache_nr); i++) {
261 const struct cache_entry *ce = active_cache(the_index.cache)[i];
262 struct string_list_item *item;
263
264 if (ce->ce_flags & CE_UPDATE(1 << 16))
265 continue;
266 if (!ce_path_match(ce, pattern, m))
267 continue;
268 item = string_list_insert(list, ce->name);
269 if (ce_skip_worktree(ce)((ce)->ce_flags & (1 << 30)))
270 item->util = item; /* better a valid pointer than a fake one */
271 }
272
273 ret = report_path_error(m, pattern, prefix);
274 free(m);
275 return ret;
276}
277
278static void add_remove_files(struct string_list *list)
279{
280 int i;
281 for (i = 0; i < list->nr; i++) {
282 struct stat st;
283 struct string_list_item *p = &(list->items[i]);
284
285 /* p->util is skip-worktree */
286 if (p->util)
287 continue;
288
289 if (!lstat(p->string, &st)) {
290 if (add_to_cache(p->string, &st, 0)add_to_index(&the_index, (p->string), (&st), (0)))
291 die(_("updating files failed"));
292 } else
293 remove_file_from_cache(p->string)remove_file_from_index(&the_index, (p->string));
294 }
295}
296
297static void create_base_index(const struct commit *current_head)
298{
299 struct tree *tree;
300 struct unpack_trees_options opts;
301 struct tree_desc t;
302
303 if (!current_head) {
304 discard_cache()discard_index(&the_index);
305 return;
306 }
307
308 memset(&opts, 0, sizeof(opts))__builtin___memset_chk (&opts, 0, sizeof(opts), __builtin_object_size
(&opts, 0))
;
309 opts.head_idx = 1;
310 opts.index_only = 1;
311 opts.merge = 1;
312 opts.src_index = &the_index;
313 opts.dst_index = &the_index;
314
315 opts.fn = oneway_merge;
316 tree = parse_tree_indirect(current_head->object.oid.hash);
317 if (!tree)
318 die(_("failed to unpack HEAD tree object"));
319 parse_tree(tree);
320 init_tree_desc(&t, tree->buffer, tree->size);
321 if (unpack_trees(1, &t, &opts))
322 exit(128); /* We've already reported the error, finish dying */
323}
324
325static void refresh_cache_or_die(int refresh_flags)
326{
327 /*
328 * refresh_flags contains REFRESH_QUIET, so the only errors
329 * are for unmerged entries.
330 */
331 if (refresh_cache(refresh_flags | REFRESH_IN_PORCELAIN)refresh_index(&the_index, (refresh_flags | 0x0020), ((void
*)0), ((void*)0), ((void*)0))
)
332 die_resolve_conflict("commit");
333}
334
335static const char *prepare_index(int argc, const char **argv, const char *prefix,
336 const struct commit *current_head, int is_status)
337{
338 struct string_list partial;
339 struct pathspec pathspec;
340 int refresh_flags = REFRESH_QUIET0x0004;
341 const char *ret;
342
343 if (is_status)
344 refresh_flags |= REFRESH_UNMERGED0x0002;
345 parse_pathspec(&pathspec, 0,
346 PATHSPEC_PREFER_FULL(1<<1),
347 prefix, argv);
348
349 if (read_cache_preload(&pathspec)read_index_preload(&the_index, (&pathspec)) < 0)
350 die(_("index file corrupt"));
351
352 if (interactive) {
353 char *old_index_env = NULL((void*)0);
354 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR1);
355
356 refresh_cache_or_die(refresh_flags);
357
358 if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK(1 << 1)))
359 die(_("unable to create temporary index"));
360
361 old_index_env = getenv(INDEX_ENVIRONMENT"GIT_INDEX_FILE");
362 setenv(INDEX_ENVIRONMENT"GIT_INDEX_FILE", get_lock_file_path(&index_lock), 1);
363
364 if (interactive_add(argc, argv, prefix, patch_interactive) != 0)
365 die(_("interactive add failed"));
366
367 if (old_index_env && *old_index_env)
368 setenv(INDEX_ENVIRONMENT"GIT_INDEX_FILE", old_index_env, 1);
369 else
370 unsetenv(INDEX_ENVIRONMENT"GIT_INDEX_FILE");
371
372 discard_cache()discard_index(&the_index);
373 read_cache_from(get_lock_file_path(&index_lock))read_index_from(&the_index, (get_lock_file_path(&index_lock
)))
;
374 if (update_main_cache_tree(WRITE_TREE_SILENT8) == 0) {
375 if (reopen_lock_file(&index_lock) < 0)
376 die(_("unable to write index file"));
377 if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK(1 << 1)))
378 die(_("unable to update temporary index"));
379 } else
380 warning(_("Failed to update main cache tree"));
381
382 commit_style = COMMIT_NORMAL;
383 return get_lock_file_path(&index_lock);
384 }
385
386 /*
387 * Non partial, non as-is commit.
388 *
389 * (1) get the real index;
390 * (2) update the_index as necessary;
391 * (3) write the_index out to the real index (still locked);
392 * (4) return the name of the locked index file.
393 *
394 * The caller should run hooks on the locked real index, and
395 * (A) if all goes well, commit the real index;
396 * (B) on failure, rollback the real index.
397 */
398 if (all || (also && pathspec.nr)) {
399 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR1);
400 add_files_to_cache(also ? prefix : NULL((void*)0), &pathspec, 0);
401 refresh_cache_or_die(refresh_flags);
402 update_main_cache_tree(WRITE_TREE_SILENT8);
403 if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK(1 << 1)))
404 die(_("unable to write new_index file"));
405 commit_style = COMMIT_NORMAL;
406 return get_lock_file_path(&index_lock);
407 }
408
409 /*
410 * As-is commit.
411 *
412 * (1) return the name of the real index file.
413 *
414 * The caller should run hooks on the real index,
415 * and create commit from the_index.
416 * We still need to refresh the index here.
417 */
418 if (!only && !pathspec.nr) {
419 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR1);
420 refresh_cache_or_die(refresh_flags);
421 if (active_cache_changed(the_index.cache_changed)
422 || !cache_tree_fully_valid(active_cache_tree(the_index.cache_tree)))
423 update_main_cache_tree(WRITE_TREE_SILENT8);
424 if (active_cache_changed(the_index.cache_changed)) {
425 if (write_locked_index(&the_index, &index_lock,
426 COMMIT_LOCK(1 << 0)))
427 die(_("unable to write new_index file"));
428 } else {
429 rollback_lock_file(&index_lock);
430 }
431 commit_style = COMMIT_AS_IS;
432 return get_index_file();
433 }
434
435 /*
436 * A partial commit.
437 *
438 * (0) find the set of affected paths;
439 * (1) get lock on the real index file;
440 * (2) update the_index with the given paths;
441 * (3) write the_index out to the real index (still locked);
442 * (4) get lock on the false index file;
443 * (5) reset the_index from HEAD;
444 * (6) update the_index the same way as (2);
445 * (7) write the_index out to the false index file;
446 * (8) return the name of the false index file (still locked);
447 *
448 * The caller should run hooks on the locked false index, and
449 * create commit from it. Then
450 * (A) if all goes well, commit the real index;
451 * (B) on failure, rollback the real index;
452 * In either case, rollback the false index.
453 */
454 commit_style = COMMIT_PARTIAL;
455
456 if (whence != FROM_COMMIT) {
457 if (whence == FROM_MERGE)
458 die(_("cannot do a partial commit during a merge."));
459 else if (whence == FROM_CHERRY_PICK)
460 die(_("cannot do a partial commit during a cherry-pick."));
461 }
462
463 string_list_init(&partial, 1);
464 if (list_paths(&partial, !current_head ? NULL((void*)0) : "HEAD", prefix, &pathspec))
465 exit(1);
466
467 discard_cache()discard_index(&the_index);
468 if (read_cache()read_index(&the_index) < 0)
469 die(_("cannot read the index"));
470
471 hold_locked_index(&index_lock, LOCK_DIE_ON_ERROR1);
472 add_remove_files(&partial);
473 refresh_cache(REFRESH_QUIET)refresh_index(&the_index, (0x0004), ((void*)0), ((void*)0
), ((void*)0))
;
474 update_main_cache_tree(WRITE_TREE_SILENT8);
475 if (write_locked_index(&the_index, &index_lock, CLOSE_LOCK(1 << 1)))
476 die(_("unable to write new_index file"));
477
478 hold_lock_file_for_update(&false_lock,
479 git_path("next-index-%"PRIuMAX"j" "u",
480 (uintmax_t) getpid()),
481 LOCK_DIE_ON_ERROR1);
482
483 create_base_index(current_head);
484 add_remove_files(&partial);
485 refresh_cache(REFRESH_QUIET)refresh_index(&the_index, (0x0004), ((void*)0), ((void*)0
), ((void*)0))
;
486
487 if (write_locked_index(&the_index, &false_lock, CLOSE_LOCK(1 << 1)))
488 die(_("unable to write temporary index file"));
489
490 discard_cache()discard_index(&the_index);
491 ret = get_lock_file_path(&false_lock);
492 read_cache_from(ret)read_index_from(&the_index, (ret));
493 return ret;
494}
495
496static int run_status(FILE *fp, const char *index_file, const char *prefix, int nowarn,
497 struct wt_status *s)
498{
499 unsigned char sha1[20];
500
501 if (s->relative_paths)
502 s->prefix = prefix;
503
504 if (amend) {
505 s->amend = 1;
506 s->reference = "HEAD^1";
507 }
508 s->verbose = verbose;
509 s->index_file = index_file;
510 s->fp = fp;
511 s->nowarn = nowarn;
512 s->is_initial = get_sha1(s->reference, sha1) ? 1 : 0;
513 if (!s->is_initial)
514 hashcpy(s->sha1_commit, sha1);
515 s->status_format = status_format;
516 s->ignore_submodule_arg = ignore_submodule_arg;
517
518 wt_status_collect(s);
519 wt_status_print(s);
520
521 return s->commitable;
522}
523
524static int is_a_merge(const struct commit *current_head)
525{
526 return !!(current_head->parents && current_head->parents->next);
527}
528
529static void assert_split_ident(struct ident_split *id, const struct strbuf *buf)
530{
531 if (split_ident_line(id, buf->buf, buf->len) || !id->date_begin)
532 die("BUG: unable to parse our own ident: %s", buf->buf);
533}
534
535static void export_one(const char *var, const char *s, const char *e, int hack)
536{
537 struct strbuf buf = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
538 if (hack)
539 strbuf_addch(&buf, hack);
540 strbuf_addf(&buf, "%.*s", (int)(e - s), s);
541 setenv(var, buf.buf, 1);
542 strbuf_release(&buf);
543}
544
545static int parse_force_date(const char *in, struct strbuf *out)
546{
547 strbuf_addch(out, '@');
548
549 if (parse_date(in, out) < 0) {
550 int errors = 0;
551 unsigned long t = approxidate_careful(in, &errors);
552 if (errors)
553 return -1;
554 strbuf_addf(out, "%lu", t);
555 }
556
557 return 0;
558}
559
560static void set_ident_var(char **buf, char *val)
561{
562 free(*buf);
563 *buf = val;
564}
565
566static void determine_author_info(struct strbuf *author_ident)
567{
568 char *name, *email, *date;
569 struct ident_split author;
570
571 name = xstrdup_or_null(getenv("GIT_AUTHOR_NAME"));
572 email = xstrdup_or_null(getenv("GIT_AUTHOR_EMAIL"));
573 date = xstrdup_or_null(getenv("GIT_AUTHOR_DATE"));
574
575 if (author_message) {
576 struct ident_split ident;
577 size_t len;
578 const char *a;
579
580 a = find_commit_header(author_message_buffer, "author", &len);
581 if (!a)
582 die(_("commit '%s' lacks author header"), author_message);
583 if (split_ident_line(&ident, a, len) < 0)
584 die(_("commit '%s' has malformed author line"), author_message);
585
586 set_ident_var(&name, xmemdupz(ident.name_begin, ident.name_end - ident.name_begin));
587 set_ident_var(&email, xmemdupz(ident.mail_begin, ident.mail_end - ident.mail_begin));
588
589 if (ident.date_begin) {
590 struct strbuf date_buf = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
591 strbuf_addch(&date_buf, '@');
592 strbuf_add(&date_buf, ident.date_begin, ident.date_end - ident.date_begin);
593 strbuf_addch(&date_buf, ' ');
594 strbuf_add(&date_buf, ident.tz_begin, ident.tz_end - ident.tz_begin);
595 set_ident_var(&date, strbuf_detach(&date_buf, NULL((void*)0)));
596 }
597 }
598
599 if (force_author) {
600 struct ident_split ident;
601
602 if (split_ident_line(&ident, force_author, strlen(force_author)) < 0)
603 die(_("malformed --author parameter"));
604 set_ident_var(&name, xmemdupz(ident.name_begin, ident.name_end - ident.name_begin));
605 set_ident_var(&email, xmemdupz(ident.mail_begin, ident.mail_end - ident.mail_begin));
606 }
607
608 if (force_date) {
609 struct strbuf date_buf = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
610 if (parse_force_date(force_date, &date_buf))
611 die(_("invalid date format: %s"), force_date);
612 set_ident_var(&date, strbuf_detach(&date_buf, NULL((void*)0)));
613 }
614
615 strbuf_addstr(author_ident, fmt_ident(name, email, date, IDENT_STRICT1));
616 assert_split_ident(&author, author_ident);
617 export_one("GIT_AUTHOR_NAME", author.name_begin, author.name_end, 0);
618 export_one("GIT_AUTHOR_EMAIL", author.mail_begin, author.mail_end, 0);
619 export_one("GIT_AUTHOR_DATE", author.date_begin, author.tz_end, '@');
620 free(name);
621 free(email);
622 free(date);
623}
624
625static int author_date_is_interesting(void)
626{
627 return author_message || force_date;
628}
629
630static void adjust_comment_line_char(const struct strbuf *sb)
631{
632 char candidates[] = "#;@!$%^&|:";
633 char *candidate;
634 const char *p;
635
636 comment_line_char = candidates[0];
637 if (!memchr(sb->buf, comment_line_char, sb->len))
638 return;
639
640 p = sb->buf;
641 candidate = strchr(candidates, *p);
642 if (candidate)
643 *candidate = ' ';
644 for (p = sb->buf; *p; p++) {
645 if ((p[0] == '\n' || p[0] == '\r') && p[1]) {
646 candidate = strchr(candidates, p[1]);
647 if (candidate)
648 *candidate = ' ';
649 }
650 }
651
652 for (p = candidates; *p == ' '; p++)
653 ;
654 if (!*p)
655 die(_("unable to select a comment character that is not used\n"
656 "in the current commit message"));
657 comment_line_char = *p;
658}
659
660static int prepare_to_commit(const char *index_file, const char *prefix,
661 struct commit *current_head,
662 struct wt_status *s,
663 struct strbuf *author_ident)
664{
665 struct stat statbuf;
666 struct strbuf committer_ident = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
667 int commitable;
668 struct strbuf sb = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
669 const char *hook_arg1 = NULL((void*)0);
670 const char *hook_arg2 = NULL((void*)0);
671 int clean_message_contents = (cleanup_mode != CLEANUP_NONE);
672 int old_display_comment_prefix;
673
674 /* This checks and barfs if author is badly specified */
675 determine_author_info(author_ident);
676
677 if (!no_verify && run_commit_hook(use_editor, index_file, "pre-commit", NULL((void*)0)))
678 return 0;
679
680 if (squash_message) {
681 /*
682 * Insert the proper subject line before other commit
683 * message options add their content.
684 */
685 if (use_message && !strcmp(use_message, squash_message))
686 strbuf_addstr(&sb, "squash! ");
687 else {
688 struct pretty_print_context ctx = {0};
689 struct commit *c;
690 c = lookup_commit_reference_by_name(squash_message);
691 if (!c)
692 die(_("could not lookup commit %s"), squash_message);
693 ctx.output_encoding = get_commit_output_encoding();
694 format_commit_message(c, "squash! %s\n\n", &sb,
695 &ctx);
696 }
697 }
698
699 if (have_option_m) {
700 strbuf_addbuf(&sb, &message);
701 hook_arg1 = "message";
702 } else if (logfile && !strcmp(logfile, "-")) {
703 if (isatty(0))
704 fprintf(stderr__stderrp, _("(reading log message from standard input)\n"));
705 if (strbuf_read(&sb, 0, 0) < 0)
706 die_errno(_("could not read log from standard input"));
707 hook_arg1 = "message";
708 } else if (logfile) {
709 if (strbuf_read_file(&sb, logfile, 0) < 0)
710 die_errno(_("could not read log file '%s'"),
711 logfile);
712 hook_arg1 = "message";
713 } else if (use_message) {
714 char *buffer;
715 buffer = strstr(use_message_buffer, "\n\n");
716 if (buffer)
717 strbuf_addstr(&sb, skip_blank_lines(buffer + 2));
718 hook_arg1 = "commit";
719 hook_arg2 = use_message;
720 } else if (fixup_message) {
721 struct pretty_print_context ctx = {0};
722 struct commit *commit;
723 commit = lookup_commit_reference_by_name(fixup_message);
724 if (!commit)
725 die(_("could not lookup commit %s"), fixup_message);
726 ctx.output_encoding = get_commit_output_encoding();
727 format_commit_message(commit, "fixup! %s\n\n",
728 &sb, &ctx);
729 hook_arg1 = "message";
730 } else if (!stat(git_path_merge_msg(), &statbuf)) {
731 /*
732 * prepend SQUASH_MSG here if it exists and a
733 * "merge --squash" was originally performed
734 */
735 if (!stat(git_path_squash_msg(), &statbuf)) {
736 if (strbuf_read_file(&sb, git_path_squash_msg(), 0) < 0)
737 die_errno(_("could not read SQUASH_MSG"));
738 hook_arg1 = "squash";
739 } else
740 hook_arg1 = "merge";
741 if (strbuf_read_file(&sb, git_path_merge_msg(), 0) < 0)
742 die_errno(_("could not read MERGE_MSG"));
743 } else if (!stat(git_path_squash_msg(), &statbuf)) {
744 if (strbuf_read_file(&sb, git_path_squash_msg(), 0) < 0)
745 die_errno(_("could not read SQUASH_MSG"));
746 hook_arg1 = "squash";
747 } else if (template_file) {
748 if (strbuf_read_file(&sb, template_file, 0) < 0)
749 die_errno(_("could not read '%s'"), template_file);
750 hook_arg1 = "template";
751 clean_message_contents = 0;
752 }
753
754 /*
755 * The remaining cases don't modify the template message, but
756 * just set the argument(s) to the prepare-commit-msg hook.
757 */
758 else if (whence == FROM_MERGE)
759 hook_arg1 = "merge";
760 else if (whence == FROM_CHERRY_PICK) {
761 hook_arg1 = "commit";
762 hook_arg2 = "CHERRY_PICK_HEAD";
763 }
764
765 if (squash_message) {
766 /*
767 * If squash_commit was used for the commit subject,
768 * then we're possibly hijacking other commit log options.
769 * Reset the hook args to tell the real story.
770 */
771 hook_arg1 = "message";
772 hook_arg2 = "";
773 }
774
775 s->fp = fopen_for_writing(git_path_commit_editmsg());
776 if (s->fp == NULL((void*)0))
777 die_errno(_("could not open '%s'"), git_path_commit_editmsg());
778
779 /* Ignore status.displayCommentPrefix: we do need comments in COMMIT_EDITMSG. */
780 old_display_comment_prefix = s->display_comment_prefix;
781 s->display_comment_prefix = 1;
782
783 /*
784 * Most hints are counter-productive when the commit has
785 * already started.
786 */
787 s->hints = 0;
788
789 if (clean_message_contents)
790 strbuf_stripspace(&sb, 0);
791
792 if (signoff)
793 append_signoff(&sb, ignore_non_trailer(sb.buf, sb.len), 0);
794
795 if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
796 die_errno(_("could not write commit template"));
797
798 if (auto_comment_line_char)
799 adjust_comment_line_char(&sb);
800 strbuf_release(&sb);
801
802 /* This checks if committer ident is explicitly given */
803 strbuf_addstr(&committer_ident, git_committer_info(IDENT_STRICT1));
804 if (use_editor && include_status) {
805 int ident_shown = 0;
806 int saved_color_setting;
807 struct ident_split ci, ai;
808
809 if (whence != FROM_COMMIT) {
810 if (cleanup_mode == CLEANUP_SCISSORS)
811 wt_status_add_cut_line(s->fp);
812 status_printf_ln(s, GIT_COLOR_NORMAL"",
813 whence == FROM_MERGE
814 ? _("\n"
815 "It looks like you may be committing a merge.\n"
816 "If this is not correct, please remove the file\n"
817 " %s\n"
818 "and try again.\n")
819 : _("\n"
820 "It looks like you may be committing a cherry-pick.\n"
821 "If this is not correct, please remove the file\n"
822 " %s\n"
823 "and try again.\n"),
824 git_path(whence == FROM_MERGE
825 ? "MERGE_HEAD"
826 : "CHERRY_PICK_HEAD"));
827 }
828
829 fprintf(s->fp, "\n");
830 if (cleanup_mode == CLEANUP_ALL)
831 status_printf(s, GIT_COLOR_NORMAL"",
832 _("Please enter the commit message for your changes."
833 " Lines starting\nwith '%c' will be ignored, and an empty"
834 " message aborts the commit.\n"), comment_line_char);
835 else if (cleanup_mode == CLEANUP_SCISSORS && whence == FROM_COMMIT)
836 wt_status_add_cut_line(s->fp);
837 else /* CLEANUP_SPACE, that is. */
838 status_printf(s, GIT_COLOR_NORMAL"",
839 _("Please enter the commit message for your changes."
840 " Lines starting\n"
841 "with '%c' will be kept; you may remove them"
842 " yourself if you want to.\n"
843 "An empty message aborts the commit.\n"), comment_line_char);
844 if (only_include_assumed)
845 status_printf_ln(s, GIT_COLOR_NORMAL"",
846 "%s", only_include_assumed);
847
848 /*
849 * These should never fail because they come from our own
850 * fmt_ident. They may fail the sane_ident test, but we know
851 * that the name and mail pointers will at least be valid,
852 * which is enough for our tests and printing here.
853 */
854 assert_split_ident(&ai, author_ident);
855 assert_split_ident(&ci, &committer_ident);
856
857 if (ident_cmp(&ai, &ci))
858 status_printf_ln(s, GIT_COLOR_NORMAL"",
859 _("%s"
860 "Author: %.*s <%.*s>"),
861 ident_shown++ ? "" : "\n",
862 (int)(ai.name_end - ai.name_begin), ai.name_begin,
863 (int)(ai.mail_end - ai.mail_begin), ai.mail_begin);
864
865 if (author_date_is_interesting())
866 status_printf_ln(s, GIT_COLOR_NORMAL"",
867 _("%s"
868 "Date: %s"),
869 ident_shown++ ? "" : "\n",
870 show_ident_date(&ai, DATE_MODE(NORMAL)date_mode_from_type(DATE_NORMAL)));
871
872 if (!committer_ident_sufficiently_given())
873 status_printf_ln(s, GIT_COLOR_NORMAL"",
874 _("%s"
875 "Committer: %.*s <%.*s>"),
876 ident_shown++ ? "" : "\n",
877 (int)(ci.name_end - ci.name_begin), ci.name_begin,
878 (int)(ci.mail_end - ci.mail_begin), ci.mail_begin);
879
880 if (ident_shown)
881 status_printf_ln(s, GIT_COLOR_NORMAL"", "%s", "");
882
883 saved_color_setting = s->use_color;
884 s->use_color = 0;
885 commitable = run_status(s->fp, index_file, prefix, 1, s);
886 s->use_color = saved_color_setting;
887 } else {
888 unsigned char sha1[20];
889 const char *parent = "HEAD";
890
891 if (!active_nr(the_index.cache_nr) && read_cache()read_index(&the_index) < 0)
892 die(_("Cannot read index"));
893
894 if (amend)
895 parent = "HEAD^1";
896
897 if (get_sha1(parent, sha1)) {
898 int i, ita_nr = 0;
899
900 for (i = 0; i < active_nr(the_index.cache_nr); i++)
901 if (ce_intent_to_add(active_cache[i])(((the_index.cache)[i])->ce_flags & (1 << 29)))
902 ita_nr++;
903 commitable = active_nr(the_index.cache_nr) - ita_nr > 0;
904 } else {
905 /*
906 * Unless the user did explicitly request a submodule
907 * ignore mode by passing a command line option we do
908 * not ignore any changed submodule SHA-1s when
909 * comparing index and parent, no matter what is
910 * configured. Otherwise we won't commit any
911 * submodules which were manually staged, which would
912 * be really confusing.
913 */
914 int diff_flags = DIFF_OPT_OVERRIDE_SUBMODULE_CONFIG(1 << 27);
915 if (ignore_submodule_arg &&
916 !strcmp(ignore_submodule_arg, "all"))
917 diff_flags |= DIFF_OPT_IGNORE_SUBMODULES(1 << 18);
918 commitable = index_differs_from(parent, diff_flags, 1);
919 }
920 }
921 strbuf_release(&committer_ident);
922
923 fclose(s->fp);
924
925 /*
926 * Reject an attempt to record a non-merge empty commit without
927 * explicit --allow-empty. In the cherry-pick case, it may be
928 * empty due to conflict resolution, which the user should okay.
929 */
930 if (!commitable && whence != FROM_MERGE && !allow_empty &&
931 !(amend && is_a_merge(current_head))) {
932 s->display_comment_prefix = old_display_comment_prefix;
933 run_status(stdout__stdoutp, index_file, prefix, 0, s);
934 if (amend)
935 fputs(_(empty_amend_advice), stderr__stderrp);
936 else if (whence == FROM_CHERRY_PICK) {
937 fputs(_(empty_cherry_pick_advice), stderr__stderrp);
938 if (!sequencer_in_use)
939 fputs(_(empty_cherry_pick_advice_single), stderr__stderrp);
940 else
941 fputs(_(empty_cherry_pick_advice_multi), stderr__stderrp);
942 }
943 return 0;
944 }
945
946 /*
947 * Re-read the index as pre-commit hook could have updated it,
948 * and write it out as a tree. We must do this before we invoke
949 * the editor and after we invoke run_status above.
950 */
951 discard_cache()discard_index(&the_index);
952 read_cache_from(index_file)read_index_from(&the_index, (index_file));
953 if (update_main_cache_tree(0)) {
954 error(_("Error building trees"))(error(_("Error building trees")), const_error());
955 return 0;
956 }
957
958 if (run_commit_hook(use_editor, index_file, "prepare-commit-msg",
959 git_path_commit_editmsg(), hook_arg1, hook_arg2, NULL((void*)0)))
960 return 0;
961
962 if (use_editor) {
963 struct argv_array env = ARGV_ARRAY_INIT{ empty_argv, 0, 0 };
964
965 argv_array_pushf(&env, "GIT_INDEX_FILE=%s", index_file);
966 if (launch_editor(git_path_commit_editmsg(), NULL((void*)0), env.argv)) {
967 fprintf(stderr__stderrp,
968 _("Please supply the message using either -m or -F option.\n"));
969 exit(1);
970 }
971 argv_array_clear(&env);
972 }
973
974 if (!no_verify &&
975 run_commit_hook(use_editor, index_file, "commit-msg", git_path_commit_editmsg(), NULL((void*)0))) {
976 return 0;
977 }
978
979 return 1;
980}
981
982static int rest_is_empty(struct strbuf *sb, int start)
983{
984 int i, eol;
985 const char *nl;
986
987 /* Check if the rest is just whitespace and Signed-of-by's. */
988 for (i = start; i < sb->len; i++) {
989 nl = memchr(sb->buf + i, '\n', sb->len - i);
990 if (nl)
991 eol = nl - sb->buf;
992 else
993 eol = sb->len;
994
995 if (strlen(sign_off_header) <= eol - i &&
996 starts_with(sb->buf + i, sign_off_header)) {
997 i = eol;
998 continue;
999 }
1000 while (i < eol)
1001 if (!isspace(sb->buf[i++])((sane_ctype[(unsigned char)(sb->buf[i++])] & (0x01)) !=
0)
)
1002 return 0;
1003 }
1004
1005 return 1;
1006}
1007
1008/*
1009 * Find out if the message in the strbuf contains only whitespace and
1010 * Signed-off-by lines.
1011 */
1012static int message_is_empty(struct strbuf *sb)
1013{
1014 if (cleanup_mode == CLEANUP_NONE && sb->len)
1015 return 0;
1016 return rest_is_empty(sb, 0);
1017}
1018
1019/*
1020 * See if the user edited the message in the editor or left what
1021 * was in the template intact
1022 */
1023static int template_untouched(struct strbuf *sb)
1024{
1025 struct strbuf tmpl = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
1026 const char *start;
1027
1028 if (cleanup_mode == CLEANUP_NONE && sb->len)
1029 return 0;
1030
1031 if (!template_file || strbuf_read_file(&tmpl, template_file, 0) <= 0)
1032 return 0;
1033
1034 strbuf_stripspace(&tmpl, cleanup_mode == CLEANUP_ALL);
1035 if (!skip_prefix(sb->buf, tmpl.buf, &start))
1036 start = sb->buf;
1037 strbuf_release(&tmpl);
1038 return rest_is_empty(sb, start - sb->buf);
1039}
1040
1041static const char *find_author_by_nickname(const char *name)
1042{
1043 struct rev_info revs;
1044 struct commit *commit;
1045 struct strbuf buf = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
1046 struct string_list mailmap = STRING_LIST_INIT_NODUP{ ((void*)0), 0, 0, 0, ((void*)0) };
1047 const char *av[20];
1048 int ac = 0;
1049
1050 init_revisions(&revs, NULL((void*)0));
1051 strbuf_addf(&buf, "--author=%s", name);
1052 av[++ac] = "--all";
1053 av[++ac] = "-i";
1054 av[++ac] = buf.buf;
1055 av[++ac] = NULL((void*)0);
1056 setup_revisions(ac, av, &revs, NULL((void*)0));
1057 revs.mailmap = &mailmap;
1058 read_mailmap(revs.mailmap, NULL((void*)0));
1059
1060 if (prepare_revision_walk(&revs))
1061 die(_("revision walk setup failed"));
1062 commit = get_revision(&revs);
1063 if (commit) {
1064 struct pretty_print_context ctx = {0};
1065 ctx.date_mode.type = DATE_NORMAL;
1066 strbuf_release(&buf);
1067 format_commit_message(commit, "%aN <%aE>", &buf, &ctx);
1068 clear_mailmap(&mailmap);
1069 return strbuf_detach(&buf, NULL((void*)0));
1070 }
1071 die(_("--author '%s' is not 'Name <email>' and matches no existing author"), name);
1072}
1073
1074
1075static void handle_untracked_files_arg(struct wt_status *s)
1076{
1077 if (!untracked_files_arg)
1078 ; /* default already initialized */
1079 else if (!strcmp(untracked_files_arg, "no"))
1080 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1081 else if (!strcmp(untracked_files_arg, "normal"))
1082 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1083 else if (!strcmp(untracked_files_arg, "all"))
1084 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1085 else
1086 die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
1087}
1088
1089static const char *read_commit_message(const char *name)
1090{
1091 const char *out_enc;
1092 struct commit *commit;
1093
1094 commit = lookup_commit_reference_by_name(name);
1095 if (!commit)
1096 die(_("could not lookup commit %s"), name);
1097 out_enc = get_commit_output_encoding();
1098 return logmsg_reencode(commit, NULL((void*)0), out_enc);
1099}
1100
1101/*
1102 * Enumerate what needs to be propagated when --porcelain
1103 * is not in effect here.
1104 */
1105static struct status_deferred_config {
1106 enum wt_status_format status_format;
1107 int show_branch;
1108} status_deferred_config = {
1109 STATUS_FORMAT_UNSPECIFIED,
1110 -1 /* unspecified */
1111};
1112
1113static void finalize_deferred_config(struct wt_status *s)
1114{
1115 int use_deferred_config = (status_format != STATUS_FORMAT_PORCELAIN &&
1116 status_format != STATUS_FORMAT_PORCELAIN_V2 &&
1117 !s->null_termination);
1118
1119 if (s->null_termination) {
1120 if (status_format == STATUS_FORMAT_NONE ||
1121 status_format == STATUS_FORMAT_UNSPECIFIED)
1122 status_format = STATUS_FORMAT_PORCELAIN;
1123 else if (status_format == STATUS_FORMAT_LONG)
1124 die(_("--long and -z are incompatible"));
1125 }
1126
1127 if (use_deferred_config && status_format == STATUS_FORMAT_UNSPECIFIED)
1128 status_format = status_deferred_config.status_format;
1129 if (status_format == STATUS_FORMAT_UNSPECIFIED)
1130 status_format = STATUS_FORMAT_NONE;
1131
1132 if (use_deferred_config && s->show_branch < 0)
1133 s->show_branch = status_deferred_config.show_branch;
1134 if (s->show_branch < 0)
1135 s->show_branch = 0;
1136}
1137
1138static int parse_and_validate_options(int argc, const char *argv[],
1139 const struct option *options,
1140 const char * const usage[],
1141 const char *prefix,
1142 struct commit *current_head,
1143 struct wt_status *s)
1144{
1145 int f = 0;
1146
1147 argc = parse_options(argc, argv, prefix, options, usage, 0);
1148 finalize_deferred_config(s);
1149
1150 if (force_author && !strchr(force_author, '>'))
1151 force_author = find_author_by_nickname(force_author);
1152
1153 if (force_author && renew_authorship)
1154 die(_("Using both --reset-author and --author does not make sense"));
1155
1156 if (logfile || have_option_m || use_message || fixup_message)
1157 use_editor = 0;
1158 if (0 <= edit_flag)
1159 use_editor = edit_flag;
1160
1161 /* Sanity check options */
1162 if (amend && !current_head)
1163 die(_("You have nothing to amend."));
1164 if (amend && whence != FROM_COMMIT) {
1165 if (whence == FROM_MERGE)
1166 die(_("You are in the middle of a merge -- cannot amend."));
1167 else if (whence == FROM_CHERRY_PICK)
1168 die(_("You are in the middle of a cherry-pick -- cannot amend."));
1169 }
1170 if (fixup_message && squash_message)
1171 die(_("Options --squash and --fixup cannot be used together"));
1172 if (use_message)
1173 f++;
1174 if (edit_message)
1175 f++;
1176 if (fixup_message)
1177 f++;
1178 if (logfile)
1179 f++;
1180 if (f > 1)
1181 die(_("Only one of -c/-C/-F/--fixup can be used."));
1182 if (have_option_m && f > 0)
1183 die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
1184 if (f || have_option_m)
1185 template_file = NULL((void*)0);
1186 if (edit_message)
1187 use_message = edit_message;
1188 if (amend && !use_message && !fixup_message)
1189 use_message = "HEAD";
1190 if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
1191 die(_("--reset-author can be used only with -C, -c or --amend."));
1192 if (use_message) {
1193 use_message_buffer = read_commit_message(use_message);
1194 if (!renew_authorship) {
1195 author_message = use_message;
1196 author_message_buffer = use_message_buffer;
1197 }
1198 }
1199 if (whence == FROM_CHERRY_PICK && !renew_authorship) {
1200 author_message = "CHERRY_PICK_HEAD";
1201 author_message_buffer = read_commit_message(author_message);
1202 }
1203
1204 if (patch_interactive)
1205 interactive = 1;
1206
1207 if (also + only + all + interactive > 1)
1208 die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
1209 if (argc == 0 && (also || (only && !amend && !allow_empty)))
1210 die(_("No paths with --include/--only does not make sense."));
1211 if (argc > 0 && !also && !only)
1212 only_include_assumed = _("Explicit paths specified without -i or -o; assuming --only paths...");
1213 if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
1214 cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
1215 else if (!strcmp(cleanup_arg, "verbatim"))
1216 cleanup_mode = CLEANUP_NONE;
1217 else if (!strcmp(cleanup_arg, "whitespace"))
1218 cleanup_mode = CLEANUP_SPACE;
1219 else if (!strcmp(cleanup_arg, "strip"))
1220 cleanup_mode = CLEANUP_ALL;
1221 else if (!strcmp(cleanup_arg, "scissors"))
1222 cleanup_mode = use_editor ? CLEANUP_SCISSORS : CLEANUP_SPACE;
1223 else
1224 die(_("Invalid cleanup mode %s"), cleanup_arg);
1225
1226 handle_untracked_files_arg(s);
1227
1228 if (all && argc > 0)
1229 die(_("Paths with -a does not make sense."));
1230
1231 if (status_format != STATUS_FORMAT_NONE)
1232 dry_run = 1;
1233
1234 return argc;
1235}
1236
1237static int dry_run_commit(int argc, const char **argv, const char *prefix,
1238 const struct commit *current_head, struct wt_status *s)
1239{
1240 int commitable;
1241 const char *index_file;
1242
1243 index_file = prepare_index(argc, argv, prefix, current_head, 1);
1244 commitable = run_status(stdout__stdoutp, index_file, prefix, 0, s);
1245 rollback_index_files();
1246
1247 return commitable ? 0 : 1;
1248}
1249
1250static int parse_status_slot(const char *slot)
1251{
1252 if (!strcasecmp(slot, "header"))
1253 return WT_STATUS_HEADER;
1254 if (!strcasecmp(slot, "branch"))
1255 return WT_STATUS_ONBRANCH;
1256 if (!strcasecmp(slot, "updated") || !strcasecmp(slot, "added"))
1257 return WT_STATUS_UPDATED;
1258 if (!strcasecmp(slot, "changed"))
1259 return WT_STATUS_CHANGED;
1260 if (!strcasecmp(slot, "untracked"))
1261 return WT_STATUS_UNTRACKED;
1262 if (!strcasecmp(slot, "nobranch"))
1263 return WT_STATUS_NOBRANCH;
1264 if (!strcasecmp(slot, "unmerged"))
1265 return WT_STATUS_UNMERGED;
1266 return -1;
1267}
1268
1269static int git_status_config(const char *k, const char *v, void *cb)
1270{
1271 struct wt_status *s = cb;
1272 const char *slot_name;
1273
1274 if (starts_with(k, "column."))
1275 return git_column_config(k, v, "status", &s->colopts);
1276 if (!strcmp(k, "status.submodulesummary")) {
1277 int is_bool;
1278 s->submodule_summary = git_config_bool_or_int(k, v, &is_bool);
1279 if (is_bool && s->submodule_summary)
1280 s->submodule_summary = -1;
1281 return 0;
1282 }
1283 if (!strcmp(k, "status.short")) {
1284 if (git_config_bool(k, v))
1285 status_deferred_config.status_format = STATUS_FORMAT_SHORT;
1286 else
1287 status_deferred_config.status_format = STATUS_FORMAT_NONE;
1288 return 0;
1289 }
1290 if (!strcmp(k, "status.branch")) {
1291 status_deferred_config.show_branch = git_config_bool(k, v);
1292 return 0;
1293 }
1294 if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
1295 s->use_color = git_config_colorbool(k, v);
1296 return 0;
1297 }
1298 if (!strcmp(k, "status.displaycommentprefix")) {
1299 s->display_comment_prefix = git_config_bool(k, v);
1300 return 0;
1301 }
1302 if (skip_prefix(k, "status.color.", &slot_name) ||
1303 skip_prefix(k, "color.status.", &slot_name)) {
1304 int slot = parse_status_slot(slot_name);
1305 if (slot < 0)
1306 return 0;
1307 if (!v)
1308 return config_error_nonbool(k)(config_error_nonbool(k), const_error());
1309 return color_parse(v, s->color_palette[slot]);
1310 }
1311 if (!strcmp(k, "status.relativepaths")) {
1312 s->relative_paths = git_config_bool(k, v);
1313 return 0;
1314 }
1315 if (!strcmp(k, "status.showuntrackedfiles")) {
1316 if (!v)
1317 return config_error_nonbool(k)(config_error_nonbool(k), const_error());
1318 else if (!strcmp(v, "no"))
1319 s->show_untracked_files = SHOW_NO_UNTRACKED_FILES;
1320 else if (!strcmp(v, "normal"))
1321 s->show_untracked_files = SHOW_NORMAL_UNTRACKED_FILES;
1322 else if (!strcmp(v, "all"))
1323 s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
1324 else
1325 return error(_("Invalid untracked files mode '%s'"), v)(error(_("Invalid untracked files mode '%s'"), v), const_error
())
;
1326 return 0;
1327 }
1328 return git_diff_ui_config(k, v, NULL((void*)0));
1329}
1330
1331int cmd_status(int argc, const char **argv, const char *prefix)
1332{
1333 static struct wt_status s;
1334 int fd;
1335 unsigned char sha1[20];
1336 static struct option builtin_status_options[] = {
1337 OPT__VERBOSE(&verbose, N_("be verbose")){ OPTION_COUNTUP, ('v'), ("verbose"), ((&verbose)), ((void
*)0), ((("be verbose"))), PARSE_OPT_NOARG }
,
1338 OPT_SET_INT('s', "short", &status_format,{ OPTION_SET_INT, ('s'), ("short"), (&status_format), ((void
*)0), (("show status concisely")), PARSE_OPT_NOARG, ((void*)0
), (STATUS_FORMAT_SHORT) }
1339 N_("show status concisely"), STATUS_FORMAT_SHORT){ OPTION_SET_INT, ('s'), ("short"), (&status_format), ((void
*)0), (("show status concisely")), PARSE_OPT_NOARG, ((void*)0
), (STATUS_FORMAT_SHORT) }
,
1340 OPT_BOOL('b', "branch", &s.show_branch,{ OPTION_SET_INT, ('b'), ("branch"), (&s.show_branch), ((
void*)0), (("show branch information")), PARSE_OPT_NOARG, ((void
*)0), (1) }
1341 N_("show branch information")){ OPTION_SET_INT, ('b'), ("branch"), (&s.show_branch), ((
void*)0), (("show branch information")), PARSE_OPT_NOARG, ((void
*)0), (1) }
,
1342 { OPTION_CALLBACK, 0, "porcelain", &status_format,
1343 N_("version")("version"), N_("machine-readable output")("machine-readable output"),
1344 PARSE_OPT_OPTARG, opt_parse_porcelain },
1345 OPT_SET_INT(0, "long", &status_format,{ OPTION_SET_INT, (0), ("long"), (&status_format), ((void
*)0), (("show status in long format (default)")), PARSE_OPT_NOARG
, ((void*)0), (STATUS_FORMAT_LONG) }
1346 N_("show status in long format (default)"),{ OPTION_SET_INT, (0), ("long"), (&status_format), ((void
*)0), (("show status in long format (default)")), PARSE_OPT_NOARG
, ((void*)0), (STATUS_FORMAT_LONG) }
1347 STATUS_FORMAT_LONG){ OPTION_SET_INT, (0), ("long"), (&status_format), ((void
*)0), (("show status in long format (default)")), PARSE_OPT_NOARG
, ((void*)0), (STATUS_FORMAT_LONG) }
,
1348 OPT_BOOL('z', "null", &s.null_termination,{ OPTION_SET_INT, ('z'), ("null"), (&s.null_termination),
((void*)0), (("terminate entries with NUL")), PARSE_OPT_NOARG
, ((void*)0), (1) }
1349 N_("terminate entries with NUL")){ OPTION_SET_INT, ('z'), ("null"), (&s.null_termination),
((void*)0), (("terminate entries with NUL")), PARSE_OPT_NOARG
, ((void*)0), (1) }
,
1350 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg,
1351 N_("mode")("mode"),
1352 N_("show untracked files, optional modes: all, normal, no. (Default: all)")("show untracked files, optional modes: all, normal, no. (Default: all)"
)
,
1353 PARSE_OPT_OPTARG, NULL((void*)0), (intptr_t)"all" },
1354 OPT_BOOL(0, "ignored", &show_ignored_in_status,{ OPTION_SET_INT, (0), ("ignored"), (&show_ignored_in_status
), ((void*)0), (("show ignored files")), PARSE_OPT_NOARG, ((void
*)0), (1) }
1355 N_("show ignored files")){ OPTION_SET_INT, (0), ("ignored"), (&show_ignored_in_status
), ((void*)0), (("show ignored files")), PARSE_OPT_NOARG, ((void
*)0), (1) }
,
1356 { OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, N_("when")("when"),
1357 N_("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)")("ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)"
)
,
1358 PARSE_OPT_OPTARG, NULL((void*)0), (intptr_t)"all" },
1359 OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")){ OPTION_CALLBACK, (0), ("column"), (&s.colopts), ("style"
), (("list untracked files in columns")), PARSE_OPT_OPTARG, parseopt_column_callback
}
,
1360 OPT_END(){ OPTION_END },
1361 };
1362
1363 if (argc == 2 && !strcmp(argv[1], "-h"))
1364 usage_with_options(builtin_status_usage, builtin_status_options);
1365
1366 status_init_config(&s, git_status_config);
1367 argc = parse_options(argc, argv, prefix,
Value stored to 'argc' is never read
1368 builtin_status_options,
1369 builtin_status_usage, 0);
1370 finalize_colopts(&s.colopts, -1);
1371 finalize_deferred_config(&s);
1372
1373 handle_untracked_files_arg(&s);
1374 if (show_ignored_in_status)
1375 s.show_ignored_files = 1;
1376 parse_pathspec(&s.pathspec, 0,
1377 PATHSPEC_PREFER_FULL(1<<1),
1378 prefix, argv);
1379
1380 read_cache_preload(&s.pathspec)read_index_preload(&the_index, (&s.pathspec));
1381 refresh_index(&the_index, REFRESH_QUIET0x0004|REFRESH_UNMERGED0x0002, &s.pathspec, NULL((void*)0), NULL((void*)0));
1382
1383 fd = hold_locked_index(&index_lock, 0);
1384
1385 s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
1386 if (!s.is_initial)
1387 hashcpy(s.sha1_commit, sha1);
1388
1389 s.ignore_submodule_arg = ignore_submodule_arg;
1390 s.status_format = status_format;
1391 s.verbose = verbose;
1392
1393 wt_status_collect(&s);
1394
1395 if (0 <= fd)
1396 update_index_if_able(&the_index, &index_lock);
1397
1398 if (s.relative_paths)
1399 s.prefix = prefix;
1400
1401 wt_status_print(&s);
1402 return 0;
1403}
1404
1405static const char *implicit_ident_advice(void)
1406{
1407 char *user_config = expand_user_path("~/.gitconfig");
1408 char *xdg_config = xdg_config_home("config");
1409 int config_exists = file_exists(user_config) || file_exists(xdg_config);
1410
1411 free(user_config);
1412 free(xdg_config);
1413
1414 if (config_exists)
1415 return _(implicit_ident_advice_config);
1416 else
1417 return _(implicit_ident_advice_noconfig);
1418
1419}
1420
1421static void print_summary(const char *prefix, const unsigned char *sha1,
1422 int initial_commit)
1423{
1424 struct rev_info rev;
1425 struct commit *commit;
1426 struct strbuf format = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
1427 unsigned char junk_sha1[20];
1428 const char *head;
1429 struct pretty_print_context pctx = {0};
1430 struct strbuf author_ident = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
1431 struct strbuf committer_ident = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
1432
1433 commit = lookup_commit(sha1);
1434 if (!commit)
1435 die(_("couldn't look up newly created commit"));
1436 if (parse_commit(commit))
1437 die(_("could not parse newly created commit"));
1438
1439 strbuf_addstr(&format, "format:%h] %s");
1440
1441 format_commit_message(commit, "%an <%ae>", &author_ident, &pctx);
1442 format_commit_message(commit, "%cn <%ce>", &committer_ident, &pctx);
1443 if (strbuf_cmp(&author_ident, &committer_ident)) {
1444 strbuf_addstr(&format, "\n Author: ");
1445 strbuf_addbuf_percentquote(&format, &author_ident);
1446 }
1447 if (author_date_is_interesting()) {
1448 struct strbuf date = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
1449 format_commit_message(commit, "%ad", &date, &pctx);
1450 strbuf_addstr(&format, "\n Date: ");
1451 strbuf_addbuf_percentquote(&format, &date);
1452 strbuf_release(&date);
1453 }
1454 if (!committer_ident_sufficiently_given()) {
1455 strbuf_addstr(&format, "\n Committer: ");
1456 strbuf_addbuf_percentquote(&format, &committer_ident);
1457 if (advice_implicit_identity) {
1458 strbuf_addch(&format, '\n');
1459 strbuf_addstr(&format, implicit_ident_advice());
1460 }
1461 }
1462 strbuf_release(&author_ident);
1463 strbuf_release(&committer_ident);
1464
1465 init_revisions(&rev, prefix);
1466 setup_revisions(0, NULL((void*)0), &rev, NULL((void*)0));
1467
1468 rev.diff = 1;
1469 rev.diffopt.output_format =
1470 DIFF_FORMAT_SHORTSTAT0x0020 | DIFF_FORMAT_SUMMARY0x0008;
1471
1472 rev.verbose_header = 1;
1473 rev.show_root_diff = 1;
1474 get_commit_format(format.buf, &rev);
1475 rev.always_show_header = 0;
1476 rev.diffopt.detect_rename = 1;
1477 rev.diffopt.break_opt = 0;
1478 diff_setup_done(&rev.diffopt);
1479
1480 head = resolve_ref_unsafe("HEAD", 0, junk_sha1, NULL((void*)0));
1481 if (!strcmp(head, "HEAD"))
1482 head = _("detached HEAD");
1483 else
1484 skip_prefix(head, "refs/heads/", &head);
1485 printf("[%s%s ", head, initial_commit ? _(" (root-commit)") : "");
1486
1487 if (!log_tree_commit(&rev, commit)) {
1488 rev.always_show_header = 1;
1489 rev.use_terminator = 1;
1490 log_tree_commit(&rev, commit);
1491 }
1492
1493 strbuf_release(&format);
1494}
1495
1496static int git_commit_config(const char *k, const char *v, void *cb)
1497{
1498 struct wt_status *s = cb;
1499 int status;
1500
1501 if (!strcmp(k, "commit.template"))
1502 return git_config_pathname(&template_file, k, v);
1503 if (!strcmp(k, "commit.status")) {
1504 include_status = git_config_bool(k, v);
1505 return 0;
1506 }
1507 if (!strcmp(k, "commit.cleanup"))
1508 return git_config_string(&cleanup_arg, k, v);
1509 if (!strcmp(k, "commit.gpgsign")) {
1510 sign_commit = git_config_bool(k, v) ? "" : NULL((void*)0);
1511 return 0;
1512 }
1513 if (!strcmp(k, "commit.verbose")) {
1514 int is_bool;
1515 config_commit_verbose = git_config_bool_or_int(k, v, &is_bool);
1516 return 0;
1517 }
1518
1519 status = git_gpg_config(k, v, NULL((void*)0));
1520 if (status)
1521 return status;
1522 return git_status_config(k, v, s);
1523}
1524
1525static int run_rewrite_hook(const unsigned char *oldsha1,
1526 const unsigned char *newsha1)
1527{
1528 struct child_process proc = CHILD_PROCESS_INIT{ ((void*)0), { empty_argv, 0, 0 }, { empty_argv, 0, 0 } };
1529 const char *argv[3];
1530 int code;
1531 struct strbuf sb = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
1532
1533 argv[0] = find_hook("post-rewrite");
1534 if (!argv[0])
1535 return 0;
1536
1537 argv[1] = "amend";
1538 argv[2] = NULL((void*)0);
1539
1540 proc.argv = argv;
1541 proc.in = -1;
1542 proc.stdout_to_stderr = 1;
1543
1544 code = start_command(&proc);
1545 if (code)
1546 return code;
1547 strbuf_addf(&sb, "%s %s\n", sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
1548 sigchain_push(SIGPIPE13, SIG_IGN(void (*)(int))1);
1549 write_in_full(proc.in, sb.buf, sb.len);
1550 close(proc.in);
1551 strbuf_release(&sb);
1552 sigchain_pop(SIGPIPE13);
1553 return finish_command(&proc);
1554}
1555
1556int run_commit_hook(int editor_is_used, const char *index_file, const char *name, ...)
1557{
1558 struct argv_array hook_env = ARGV_ARRAY_INIT{ empty_argv, 0, 0 };
1559 va_list args;
1560 int ret;
1561
1562 argv_array_pushf(&hook_env, "GIT_INDEX_FILE=%s", index_file);
1563
1564 /*
1565 * Let the hook know that no editor will be launched.
1566 */
1567 if (!editor_is_used)
1568 argv_array_push(&hook_env, "GIT_EDITOR=:");
1569
1570 va_start(args, name)__builtin_va_start(args, name);
1571 ret = run_hook_ve(hook_env.argv,name, args);
1572 va_end(args)__builtin_va_end(args);
1573 argv_array_clear(&hook_env);
1574
1575 return ret;
1576}
1577
1578int cmd_commit(int argc, const char **argv, const char *prefix)
1579{
1580 static struct wt_status s;
1581 static struct option builtin_commit_options[] = {
1582 OPT__QUIET(&quiet, N_("suppress summary after successful commit")){ OPTION_COUNTUP, ('q'), ("quiet"), ((&quiet)), ((void*)0
), ((("suppress summary after successful commit"))), PARSE_OPT_NOARG
}
,
1583 OPT__VERBOSE(&verbose, N_("show diff in commit message template")){ OPTION_COUNTUP, ('v'), ("verbose"), ((&verbose)), ((void
*)0), ((("show diff in commit message template"))), PARSE_OPT_NOARG
}
,
1584
1585 OPT_GROUP(N_("Commit message options")){ OPTION_GROUP, 0, ((void*)0), ((void*)0), ((void*)0), (("Commit message options"
)) }
,
1586 OPT_FILENAME('F', "file", &logfile, N_("read message from file")){ OPTION_FILENAME, ('F'), ("file"), (&logfile), ("file"),
(("read message from file")) }
,
1587 OPT_STRING(0, "author", &force_author, N_("author"), N_("override author for commit")){ OPTION_STRING, (0), ("author"), (&force_author), (("author"
)), (("override author for commit")) }
,
1588 OPT_STRING(0, "date", &force_date, N_("date"), N_("override date for commit")){ OPTION_STRING, (0), ("date"), (&force_date), (("date"))
, (("override date for commit")) }
,
1589 OPT_CALLBACK('m', "message", &message, N_("message"), N_("commit message"), opt_parse_m){ OPTION_CALLBACK, ('m'), ("message"), (&message), (("message"
)), (("commit message")), 0, (opt_parse_m) }
,
1590 OPT_STRING('c', "reedit-message", &edit_message, N_("commit"), N_("reuse and edit message from specified commit")){ OPTION_STRING, ('c'), ("reedit-message"), (&edit_message
), (("commit")), (("reuse and edit message from specified commit"
)) }
,
1591 OPT_STRING('C', "reuse-message", &use_message, N_("commit"), N_("reuse message from specified commit")){ OPTION_STRING, ('C'), ("reuse-message"), (&use_message)
, (("commit")), (("reuse message from specified commit")) }
,
1592 OPT_STRING(0, "fixup", &fixup_message, N_("commit"), N_("use autosquash formatted message to fixup specified commit")){ OPTION_STRING, (0), ("fixup"), (&fixup_message), (("commit"
)), (("use autosquash formatted message to fixup specified commit"
)) }
,
1593 OPT_STRING(0, "squash", &squash_message, N_("commit"), N_("use autosquash formatted message to squash specified commit")){ OPTION_STRING, (0), ("squash"), (&squash_message), (("commit"
)), (("use autosquash formatted message to squash specified commit"
)) }
,
1594 OPT_BOOL(0, "reset-author", &renew_authorship, N_("the commit is authored by me now (used with -C/-c/--amend)")){ OPTION_SET_INT, (0), ("reset-author"), (&renew_authorship
), ((void*)0), (("the commit is authored by me now (used with -C/-c/--amend)"
)), PARSE_OPT_NOARG, ((void*)0), (1) }
,
1595 OPT_BOOL('s', "signoff", &signoff, N_("add Signed-off-by:")){ OPTION_SET_INT, ('s'), ("signoff"), (&signoff), ((void*
)0), (("add Signed-off-by:")), PARSE_OPT_NOARG, ((void*)0), (
1) }
,
1596 OPT_FILENAME('t', "template", &template_file, N_("use specified template file")){ OPTION_FILENAME, ('t'), ("template"), (&template_file),
("file"), (("use specified template file")) }
,
1597 OPT_BOOL('e', "edit", &edit_flag, N_("force edit of commit")){ OPTION_SET_INT, ('e'), ("edit"), (&edit_flag), ((void*)
0), (("force edit of commit")), PARSE_OPT_NOARG, ((void*)0), (
1) }
,
1598 OPT_STRING(0, "cleanup", &cleanup_arg, N_("default"), N_("how to strip spaces and #comments from message")){ OPTION_STRING, (0), ("cleanup"), (&cleanup_arg), (("default"
)), (("how to strip spaces and #comments from message")) }
,
1599 OPT_BOOL(0, "status", &include_status, N_("include status in commit message template")){ OPTION_SET_INT, (0), ("status"), (&include_status), ((void
*)0), (("include status in commit message template")), PARSE_OPT_NOARG
, ((void*)0), (1) }
,
1600 { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id")("key-id"),
1601 N_("GPG sign commit")("GPG sign commit"), PARSE_OPT_OPTARG, NULL((void*)0), (intptr_t) "" },
1602 /* end commit message options */
1603
1604 OPT_GROUP(N_("Commit contents options")){ OPTION_GROUP, 0, ((void*)0), ((void*)0), ((void*)0), (("Commit contents options"
)) }
,
1605 OPT_BOOL('a', "all", &all, N_("commit all changed files")){ OPTION_SET_INT, ('a'), ("all"), (&all), ((void*)0), (("commit all changed files"
)), PARSE_OPT_NOARG, ((void*)0), (1) }
,
1606 OPT_BOOL('i', "include", &also, N_("add specified files to index for commit")){ OPTION_SET_INT, ('i'), ("include"), (&also), ((void*)0)
, (("add specified files to index for commit")), PARSE_OPT_NOARG
, ((void*)0), (1) }
,
1607 OPT_BOOL(0, "interactive", &interactive, N_("interactively add files")){ OPTION_SET_INT, (0), ("interactive"), (&interactive), (
(void*)0), (("interactively add files")), PARSE_OPT_NOARG, ((
void*)0), (1) }
,
1608 OPT_BOOL('p', "patch", &patch_interactive, N_("interactively add changes")){ OPTION_SET_INT, ('p'), ("patch"), (&patch_interactive),
((void*)0), (("interactively add changes")), PARSE_OPT_NOARG
, ((void*)0), (1) }
,
1609 OPT_BOOL('o', "only", &only, N_("commit only specified files")){ OPTION_SET_INT, ('o'), ("only"), (&only), ((void*)0), (
("commit only specified files")), PARSE_OPT_NOARG, ((void*)0)
, (1) }
,
1610 OPT_BOOL('n', "no-verify", &no_verify, N_("bypass pre-commit and commit-msg hooks")){ OPTION_SET_INT, ('n'), ("no-verify"), (&no_verify), ((void
*)0), (("bypass pre-commit and commit-msg hooks")), PARSE_OPT_NOARG
, ((void*)0), (1) }
,
1611 OPT_BOOL(0, "dry-run", &dry_run, N_("show what would be committed")){ OPTION_SET_INT, (0), ("dry-run"), (&dry_run), ((void*)0
), (("show what would be committed")), PARSE_OPT_NOARG, ((void
*)0), (1) }
,
1612 OPT_SET_INT(0, "short", &status_format, N_("show status concisely"),{ OPTION_SET_INT, (0), ("short"), (&status_format), ((void
*)0), (("show status concisely")), PARSE_OPT_NOARG, ((void*)0
), (STATUS_FORMAT_SHORT) }
1613 STATUS_FORMAT_SHORT){ OPTION_SET_INT, (0), ("short"), (&status_format), ((void
*)0), (("show status concisely")), PARSE_OPT_NOARG, ((void*)0
), (STATUS_FORMAT_SHORT) }
,
1614 OPT_BOOL(0, "branch", &s.show_branch, N_("show branch information")){ OPTION_SET_INT, (0), ("branch"), (&s.show_branch), ((void
*)0), (("show branch information")), PARSE_OPT_NOARG, ((void*
)0), (1) }
,
1615 OPT_SET_INT(0, "porcelain", &status_format,{ OPTION_SET_INT, (0), ("porcelain"), (&status_format), (
(void*)0), (("machine-readable output")), PARSE_OPT_NOARG, ((
void*)0), (STATUS_FORMAT_PORCELAIN) }
1616 N_("machine-readable output"), STATUS_FORMAT_PORCELAIN){ OPTION_SET_INT, (0), ("porcelain"), (&status_format), (
(void*)0), (("machine-readable output")), PARSE_OPT_NOARG, ((
void*)0), (STATUS_FORMAT_PORCELAIN) }
,
1617 OPT_SET_INT(0, "long", &status_format,{ OPTION_SET_INT, (0), ("long"), (&status_format), ((void
*)0), (("show status in long format (default)")), PARSE_OPT_NOARG
, ((void*)0), (STATUS_FORMAT_LONG) }
1618 N_("show status in long format (default)"),{ OPTION_SET_INT, (0), ("long"), (&status_format), ((void
*)0), (("show status in long format (default)")), PARSE_OPT_NOARG
, ((void*)0), (STATUS_FORMAT_LONG) }
1619 STATUS_FORMAT_LONG){ OPTION_SET_INT, (0), ("long"), (&status_format), ((void
*)0), (("show status in long format (default)")), PARSE_OPT_NOARG
, ((void*)0), (STATUS_FORMAT_LONG) }
,
1620 OPT_BOOL('z', "null", &s.null_termination,{ OPTION_SET_INT, ('z'), ("null"), (&s.null_termination),
((void*)0), (("terminate entries with NUL")), PARSE_OPT_NOARG
, ((void*)0), (1) }
1621 N_("terminate entries with NUL")){ OPTION_SET_INT, ('z'), ("null"), (&s.null_termination),
((void*)0), (("terminate entries with NUL")), PARSE_OPT_NOARG
, ((void*)0), (1) }
,
1622 OPT_BOOL(0, "amend", &amend, N_("amend previous commit")){ OPTION_SET_INT, (0), ("amend"), (&amend), ((void*)0), (
("amend previous commit")), PARSE_OPT_NOARG, ((void*)0), (1) }
,
1623 OPT_BOOL(0, "no-post-rewrite", &no_post_rewrite, N_("bypass post-rewrite hook")){ OPTION_SET_INT, (0), ("no-post-rewrite"), (&no_post_rewrite
), ((void*)0), (("bypass post-rewrite hook")), PARSE_OPT_NOARG
, ((void*)0), (1) }
,
1624 { OPTION_STRING, 'u', "untracked-files", &untracked_files_arg, N_("mode")("mode"), N_("show untracked files, optional modes: all, normal, no. (Default: all)")("show untracked files, optional modes: all, normal, no. (Default: all)"
)
, PARSE_OPT_OPTARG, NULL((void*)0), (intptr_t)"all" },
1625 /* end commit contents options */
1626
1627 OPT_HIDDEN_BOOL(0, "allow-empty", &allow_empty,{ OPTION_SET_INT, (0), ("allow-empty"), (&allow_empty), (
(void*)0), (("ok to record an empty change")), PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN, ((void*)0), 1}
1628 N_("ok to record an empty change")){ OPTION_SET_INT, (0), ("allow-empty"), (&allow_empty), (
(void*)0), (("ok to record an empty change")), PARSE_OPT_NOARG
| PARSE_OPT_HIDDEN, ((void*)0), 1}
,
1629 OPT_HIDDEN_BOOL(0, "allow-empty-message", &allow_empty_message,{ OPTION_SET_INT, (0), ("allow-empty-message"), (&allow_empty_message
), ((void*)0), (("ok to record a change with an empty message"
)), PARSE_OPT_NOARG | PARSE_OPT_HIDDEN, ((void*)0), 1}
1630 N_("ok to record a change with an empty message")){ OPTION_SET_INT, (0), ("allow-empty-message"), (&allow_empty_message
), ((void*)0), (("ok to record a change with an empty message"
)), PARSE_OPT_NOARG | PARSE_OPT_HIDDEN, ((void*)0), 1}
,
1631
1632 OPT_END(){ OPTION_END }
1633 };
1634
1635 struct strbuf sb = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
1636 struct strbuf author_ident = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
1637 const char *index_file, *reflog_msg;
1638 char *nl;
1639 unsigned char sha1[20];
1640 struct commit_list *parents = NULL((void*)0);
1641 struct stat statbuf;
1642 struct commit *current_head = NULL((void*)0);
1643 struct commit_extra_header *extra = NULL((void*)0);
1644 struct ref_transaction *transaction;
1645 struct strbuf err = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
1646
1647 if (argc == 2 && !strcmp(argv[1], "-h"))
1648 usage_with_options(builtin_commit_usage, builtin_commit_options);
1649
1650 status_init_config(&s, git_commit_config);
1651 status_format = STATUS_FORMAT_NONE; /* Ignore status.short */
1652 s.colopts = 0;
1653
1654 if (get_sha1("HEAD", sha1))
1655 current_head = NULL((void*)0);
1656 else {
1657 current_head = lookup_commit_or_die(sha1, "HEAD");
1658 if (parse_commit(current_head))
1659 die(_("could not parse HEAD commit"));
1660 }
1661 verbose = -1; /* unspecified */
1662 argc = parse_and_validate_options(argc, argv, builtin_commit_options,
1663 builtin_commit_usage,
1664 prefix, current_head, &s);
1665 if (verbose == -1)
1666 verbose = (config_commit_verbose < 0) ? 0 : config_commit_verbose;
1667
1668 if (dry_run)
1669 return dry_run_commit(argc, argv, prefix, current_head, &s);
1670 index_file = prepare_index(argc, argv, prefix, current_head, 0);
1671
1672 /* Set up everything for writing the commit object. This includes
1673 running hooks, writing the trees, and interacting with the user. */
1674 if (!prepare_to_commit(index_file, prefix,
1675 current_head, &s, &author_ident)) {
1676 rollback_index_files();
1677 return 1;
1678 }
1679
1680 /* Determine parents */
1681 reflog_msg = getenv("GIT_REFLOG_ACTION");
1682 if (!current_head) {
1683 if (!reflog_msg)
1684 reflog_msg = "commit (initial)";
1685 } else if (amend) {
1686 if (!reflog_msg)
1687 reflog_msg = "commit (amend)";
1688 parents = copy_commit_list(current_head->parents);
1689 } else if (whence == FROM_MERGE) {
1690 struct strbuf m = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
1691 FILE *fp;
1692 int allow_fast_forward = 1;
1693 struct commit_list **pptr = &parents;
1694
1695 if (!reflog_msg)
1696 reflog_msg = "commit (merge)";
1697 pptr = commit_list_append(current_head, pptr);
1698 fp = fopen(git_path_merge_head(), "r");
1699 if (fp == NULL((void*)0))
1700 die_errno(_("could not open '%s' for reading"),
1701 git_path_merge_head());
1702 while (strbuf_getline_lf(&m, fp) != EOF(-1)) {
1703 struct commit *parent;
1704
1705 parent = get_merge_parent(m.buf);
1706 if (!parent)
1707 die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
1708 pptr = commit_list_append(parent, pptr);
1709 }
1710 fclose(fp);
1711 strbuf_release(&m);
1712 if (!stat(git_path_merge_mode(), &statbuf)) {
1713 if (strbuf_read_file(&sb, git_path_merge_mode(), 0) < 0)
1714 die_errno(_("could not read MERGE_MODE"));
1715 if (!strcmp(sb.buf, "no-ff"))
1716 allow_fast_forward = 0;
1717 }
1718 if (allow_fast_forward)
1719 parents = reduce_heads(parents);
1720 } else {
1721 if (!reflog_msg)
1722 reflog_msg = (whence == FROM_CHERRY_PICK)
1723 ? "commit (cherry-pick)"
1724 : "commit";
1725 commit_list_insert(current_head, &parents);
1726 }
1727
1728 /* Finally, get the commit message */
1729 strbuf_reset(&sb)strbuf_setlen(&sb, 0);
1730 if (strbuf_read_file(&sb, git_path_commit_editmsg(), 0) < 0) {
1731 int saved_errno = errno(*__error());
1732 rollback_index_files();
1733 die(_("could not read commit message: %s"), strerror(saved_errno));
1734 }
1735
1736 if (verbose || /* Truncate the message just before the diff, if any. */
1737 cleanup_mode == CLEANUP_SCISSORS)
1738 wt_status_truncate_message_at_cut_line(&sb);
1739
1740 if (cleanup_mode != CLEANUP_NONE)
1741 strbuf_stripspace(&sb, cleanup_mode == CLEANUP_ALL);
1742 if (template_untouched(&sb) && !allow_empty_message) {
1743 rollback_index_files();
1744 fprintf(stderr__stderrp, _("Aborting commit; you did not edit the message.\n"));
1745 exit(1);
1746 }
1747 if (message_is_empty(&sb) && !allow_empty_message) {
1748 rollback_index_files();
1749 fprintf(stderr__stderrp, _("Aborting commit due to empty commit message.\n"));
1750 exit(1);
1751 }
1752
1753 if (amend) {
1754 const char *exclude_gpgsig[2] = { "gpgsig", NULL((void*)0) };
1755 extra = read_commit_extra_headers(current_head, exclude_gpgsig);
1756 } else {
1757 struct commit_extra_header **tail = &extra;
1758 append_merge_tag_headers(parents, &tail);
1759 }
1760
1761 if (commit_tree_extended(sb.buf, sb.len, active_cache_tree(the_index.cache_tree)->sha1,
1762 parents, sha1, author_ident.buf, sign_commit, extra)) {
1763 rollback_index_files();
1764 die(_("failed to write commit object"));
1765 }
1766 strbuf_release(&author_ident);
1767 free_commit_extra_headers(extra);
1768
1769 nl = strchr(sb.buf, '\n');
1770 if (nl)
1771 strbuf_setlen(&sb, nl + 1 - sb.buf);
1772 else
1773 strbuf_addch(&sb, '\n');
1774 strbuf_insert(&sb, 0, reflog_msg, strlen(reflog_msg));
1775 strbuf_insert(&sb, strlen(reflog_msg), ": ", 2);
1776
1777 transaction = ref_transaction_begin(&err);
1778 if (!transaction ||
1779 ref_transaction_update(transaction, "HEAD", sha1,
1780 current_head
1781 ? current_head->object.oid.hash : null_sha1,
1782 0, sb.buf, &err) ||
1783 ref_transaction_commit(transaction, &err)) {
1784 rollback_index_files();
1785 die("%s", err.buf);
1786 }
1787 ref_transaction_free(transaction);
1788
1789 unlink(git_path_cherry_pick_head());
1790 unlink(git_path_revert_head());
1791 unlink(git_path_merge_head());
1792 unlink(git_path_merge_msg());
1793 unlink(git_path_merge_mode());
1794 unlink(git_path_squash_msg());
1795
1796 if (commit_index_files())
1797 die (_("Repository has been updated, but unable to write\n"
1798 "new_index file. Check that disk is not full and quota is\n"
1799 "not exceeded, and then \"git reset HEAD\" to recover."));
1800
1801 rerere(0);
1802 run_commit_hook(use_editor, get_index_file(), "post-commit", NULL((void*)0));
1803 if (amend && !no_post_rewrite) {
1804 struct notes_rewrite_cfg *cfg;
1805 cfg = init_copy_notes_for_rewrite("amend");
1806 if (cfg) {
1807 /* we are amending, so current_head is not NULL */
1808 copy_note_for_rewrite(cfg, current_head->object.oid.hash, sha1);
1809 finish_copy_notes_for_rewrite(cfg, "Notes added by 'git commit --amend'");
1810 }
1811 run_rewrite_hook(current_head->object.oid.hash, sha1);
1812 }
1813 if (!quiet)
1814 print_summary(prefix, sha1, !current_head);
1815
1816 strbuf_release(&err);
1817 return 0;
1818}