builtin/commit.c

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
37	static const char * const builtin_commit_usage[] = {
38	N_("git commit [<options>] [--] <pathspec>...")("git commit [<options>] [--] <pathspec>..."),
39	NULL((void*)0)
40	};
41
42	static const char * const builtin_status_usage[] = {
43	N_("git status [<options>] [--] <pathspec>...")("git status [<options>] [--] <pathspec>..."),
44	NULL((void*)0)
45	};
46
47	static const char implicit_ident_advice_noconfig[] =
48	N_("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
60	static const char implicit_ident_advice_config[] =
61	N_("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
72	static const char empty_amend_advice[] =
73	N_("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
77	static const char empty_cherry_pick_advice[] =
78	N_("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
84	static const char empty_cherry_pick_advice_single[] =
85	N_("Otherwise, please use 'git reset'\n")("Otherwise, please use 'git reset'\n");
86
87	static const char empty_cherry_pick_advice_multi[] =
88	N_("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
95	static 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
97	static const char *use_message_buffer;
98	static struct lock_file index_lock; /* real index */
99	static struct lock_file false_lock; /* used only for partial commits */
100	static enum {
101	COMMIT_AS_IS = 1,
102	COMMIT_NORMAL,
103	COMMIT_PARTIAL
104	} commit_style;
105
106	static const char logfile, force_author;
107	static const char *template_file;
108	/*
109	* The _message variables are commit names from which to take
110	* the commit message and/or authorship.
111	*/
112	static const char author_message, author_message_buffer;
113	static char edit_message, use_message;
114	static char fixup_message, squash_message;
115	static int all, also, interactive, patch_interactive, only, amend, signoff;
116	static int edit_flag = -1; /* unspecified */
117	static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
118	static int config_commit_verbose = -1; /* unspecified */
119	static int no_post_rewrite, allow_empty_message;
120	static char untracked_files_arg, force_date, *ignore_submodule_arg;
121	static 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	*/
130	static enum {
131	CLEANUP_SPACE,
132	CLEANUP_NONE,
133	CLEANUP_SCISSORS,
134	CLEANUP_ALL
135	} cleanup_mode;
136	static const char *cleanup_arg;
137
138	static enum commit_whence whence;
139	static int sequencer_in_use;
140	static int use_editor = 1, include_status = 1;
141	static int show_ignored_in_status, have_option_m;
142	static const char *only_include_assumed;
143	static struct strbuf message = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
144
145	static enum wt_status_format status_format = STATUS_FORMAT_UNSPECIFIED;
146
147	static 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
164	static 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
180	static 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
195	static 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
205	static 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
220	static 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	*/
243	static 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
278	static 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
297	static 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
325	static 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
335	static 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
496	static 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
524	static int is_a_merge(const struct commit *current_head)
525	{
526	return !!(current_head->parents && current_head->parents->next);
527	}
528
529	static 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
535	static 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
545	static 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
560	static void set_ident_var(char *buf, char val)
561	{
562	free(*buf);
563	*buf = val;
564	}
565
566	static 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
625	static int author_date_is_interesting(void)
626	{
627	return author_message \|\| force_date;
628	}
629
630	static 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
660	static 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
982	static 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	*/
1012	static 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	*/
1023	static 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
1041	static 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
1075	static 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
1089	static 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	*/
1105	static 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
1113	static 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
1138	static 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
1237	static 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
1250	static 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
1269	static 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
1331	int 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
1405	static 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
1421	static 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
1496	static 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
1525	static 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
1556	int 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
1578	int 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	}