ci: avoid brew for installing perforce
[git/debian.git] / builtin / add.c
blob3ffb86a43384f21cad4fdcc0d8549e37dba12227
1 /*
2 * "git add" builtin command
4 * Copyright (C) 2006 Linus Torvalds
5 */
6 #define USE_THE_INDEX_COMPATIBILITY_MACROS
7 #include "cache.h"
8 #include "config.h"
9 #include "builtin.h"
10 #include "lockfile.h"
11 #include "dir.h"
12 #include "pathspec.h"
13 #include "exec-cmd.h"
14 #include "cache-tree.h"
15 #include "run-command.h"
16 #include "parse-options.h"
17 #include "diff.h"
18 #include "diffcore.h"
19 #include "revision.h"
20 #include "bulk-checkin.h"
21 #include "strvec.h"
22 #include "submodule.h"
23 #include "add-interactive.h"
25 static const char * const builtin_add_usage[] = {
26 N_("git add [<options>] [--] <pathspec>..."),
27 NULL
29 static int patch_interactive, add_interactive, edit_interactive;
30 static int take_worktree_changes;
31 static int add_renormalize;
32 static int pathspec_file_nul;
33 static int include_sparse;
34 static const char *pathspec_from_file;
36 struct update_callback_data {
37 int flags;
38 int add_errors;
41 static int chmod_pathspec(struct pathspec *pathspec, char flip, int show_only)
43 int i, ret = 0;
45 for (i = 0; i < active_nr; i++) {
46 struct cache_entry *ce = active_cache[i];
47 int err;
49 if (!include_sparse &&
50 (ce_skip_worktree(ce) ||
51 !path_in_sparse_checkout(ce->name, &the_index)))
52 continue;
54 if (pathspec && !ce_path_match(&the_index, ce, pathspec, NULL))
55 continue;
57 if (!show_only)
58 err = chmod_cache_entry(ce, flip);
59 else
60 err = S_ISREG(ce->ce_mode) ? 0 : -1;
62 if (err < 0)
63 ret = error(_("cannot chmod %cx '%s'"), flip, ce->name);
66 return ret;
69 static int fix_unmerged_status(struct diff_filepair *p,
70 struct update_callback_data *data)
72 if (p->status != DIFF_STATUS_UNMERGED)
73 return p->status;
74 if (!(data->flags & ADD_CACHE_IGNORE_REMOVAL) && !p->two->mode)
76 * This is not an explicit add request, and the
77 * path is missing from the working tree (deleted)
79 return DIFF_STATUS_DELETED;
80 else
82 * Either an explicit add request, or path exists
83 * in the working tree. An attempt to explicitly
84 * add a path that does not exist in the working tree
85 * will be caught as an error by the caller immediately.
87 return DIFF_STATUS_MODIFIED;
90 static void update_callback(struct diff_queue_struct *q,
91 struct diff_options *opt, void *cbdata)
93 int i;
94 struct update_callback_data *data = cbdata;
96 for (i = 0; i < q->nr; i++) {
97 struct diff_filepair *p = q->queue[i];
98 const char *path = p->one->path;
100 if (!include_sparse && !path_in_sparse_checkout(path, &the_index))
101 continue;
103 switch (fix_unmerged_status(p, data)) {
104 default:
105 die(_("unexpected diff status %c"), p->status);
106 case DIFF_STATUS_MODIFIED:
107 case DIFF_STATUS_TYPE_CHANGED:
108 if (add_file_to_index(&the_index, path, data->flags)) {
109 if (!(data->flags & ADD_CACHE_IGNORE_ERRORS))
110 die(_("updating files failed"));
111 data->add_errors++;
113 break;
114 case DIFF_STATUS_DELETED:
115 if (data->flags & ADD_CACHE_IGNORE_REMOVAL)
116 break;
117 if (!(data->flags & ADD_CACHE_PRETEND))
118 remove_file_from_index(&the_index, path);
119 if (data->flags & (ADD_CACHE_PRETEND|ADD_CACHE_VERBOSE))
120 printf(_("remove '%s'\n"), path);
121 break;
126 int add_files_to_cache(const char *prefix,
127 const struct pathspec *pathspec, int flags)
129 struct update_callback_data data;
130 struct rev_info rev;
132 memset(&data, 0, sizeof(data));
133 data.flags = flags;
135 repo_init_revisions(the_repository, &rev, prefix);
136 setup_revisions(0, NULL, &rev, NULL);
137 if (pathspec)
138 copy_pathspec(&rev.prune_data, pathspec);
139 rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
140 rev.diffopt.format_callback = update_callback;
141 rev.diffopt.format_callback_data = &data;
142 rev.diffopt.flags.override_submodule_config = 1;
143 rev.max_count = 0; /* do not compare unmerged paths with stage #2 */
144 run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);
145 clear_pathspec(&rev.prune_data);
146 return !!data.add_errors;
149 static int renormalize_tracked_files(const struct pathspec *pathspec, int flags)
151 int i, retval = 0;
153 for (i = 0; i < active_nr; i++) {
154 struct cache_entry *ce = active_cache[i];
156 if (!include_sparse &&
157 (ce_skip_worktree(ce) ||
158 !path_in_sparse_checkout(ce->name, &the_index)))
159 continue;
160 if (ce_stage(ce))
161 continue; /* do not touch unmerged paths */
162 if (!S_ISREG(ce->ce_mode) && !S_ISLNK(ce->ce_mode))
163 continue; /* do not touch non blobs */
164 if (pathspec && !ce_path_match(&the_index, ce, pathspec, NULL))
165 continue;
166 retval |= add_file_to_cache(ce->name, flags | ADD_CACHE_RENORMALIZE);
169 return retval;
172 static char *prune_directory(struct dir_struct *dir, struct pathspec *pathspec, int prefix)
174 char *seen;
175 int i;
176 struct dir_entry **src, **dst;
178 seen = xcalloc(pathspec->nr, 1);
180 src = dst = dir->entries;
181 i = dir->nr;
182 while (--i >= 0) {
183 struct dir_entry *entry = *src++;
184 if (dir_path_match(&the_index, entry, pathspec, prefix, seen))
185 *dst++ = entry;
187 dir->nr = dst - dir->entries;
188 add_pathspec_matches_against_index(pathspec, &the_index, seen,
189 PS_IGNORE_SKIP_WORKTREE);
190 return seen;
193 static int refresh(int verbose, const struct pathspec *pathspec)
195 char *seen;
196 int i, ret = 0;
197 char *skip_worktree_seen = NULL;
198 struct string_list only_match_skip_worktree = STRING_LIST_INIT_NODUP;
199 int flags = REFRESH_IGNORE_SKIP_WORKTREE |
200 (verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET);
202 seen = xcalloc(pathspec->nr, 1);
203 refresh_index(&the_index, flags, pathspec, seen,
204 _("Unstaged changes after refreshing the index:"));
205 for (i = 0; i < pathspec->nr; i++) {
206 if (!seen[i]) {
207 const char *path = pathspec->items[i].original;
209 if (matches_skip_worktree(pathspec, i, &skip_worktree_seen) ||
210 !path_in_sparse_checkout(path, &the_index)) {
211 string_list_append(&only_match_skip_worktree,
212 pathspec->items[i].original);
213 } else {
214 die(_("pathspec '%s' did not match any files"),
215 pathspec->items[i].original);
220 if (only_match_skip_worktree.nr) {
221 advise_on_updating_sparse_paths(&only_match_skip_worktree);
222 ret = 1;
225 free(seen);
226 free(skip_worktree_seen);
227 string_list_clear(&only_match_skip_worktree, 0);
228 return ret;
231 int run_add_interactive(const char *revision, const char *patch_mode,
232 const struct pathspec *pathspec)
234 int status, i;
235 struct strvec argv = STRVEC_INIT;
236 int use_builtin_add_i =
237 git_env_bool("GIT_TEST_ADD_I_USE_BUILTIN", -1);
239 if (use_builtin_add_i < 0) {
240 int experimental;
241 if (!git_config_get_bool("add.interactive.usebuiltin",
242 &use_builtin_add_i))
243 ; /* ok */
244 else if (!git_config_get_bool("feature.experimental", &experimental) &&
245 experimental)
246 use_builtin_add_i = 1;
249 if (use_builtin_add_i == 1) {
250 enum add_p_mode mode;
252 if (!patch_mode)
253 return !!run_add_i(the_repository, pathspec);
255 if (!strcmp(patch_mode, "--patch"))
256 mode = ADD_P_ADD;
257 else if (!strcmp(patch_mode, "--patch=stash"))
258 mode = ADD_P_STASH;
259 else if (!strcmp(patch_mode, "--patch=reset"))
260 mode = ADD_P_RESET;
261 else if (!strcmp(patch_mode, "--patch=checkout"))
262 mode = ADD_P_CHECKOUT;
263 else if (!strcmp(patch_mode, "--patch=worktree"))
264 mode = ADD_P_WORKTREE;
265 else
266 die("'%s' not supported", patch_mode);
268 return !!run_add_p(the_repository, mode, revision, pathspec);
271 strvec_push(&argv, "add--interactive");
272 if (patch_mode)
273 strvec_push(&argv, patch_mode);
274 if (revision)
275 strvec_push(&argv, revision);
276 strvec_push(&argv, "--");
277 for (i = 0; i < pathspec->nr; i++)
278 /* pass original pathspec, to be re-parsed */
279 strvec_push(&argv, pathspec->items[i].original);
281 status = run_command_v_opt(argv.v, RUN_GIT_CMD);
282 strvec_clear(&argv);
283 return status;
286 int interactive_add(const char **argv, const char *prefix, int patch)
288 struct pathspec pathspec;
290 parse_pathspec(&pathspec, 0,
291 PATHSPEC_PREFER_FULL |
292 PATHSPEC_SYMLINK_LEADING_PATH |
293 PATHSPEC_PREFIX_ORIGIN,
294 prefix, argv);
296 return run_add_interactive(NULL,
297 patch ? "--patch" : NULL,
298 &pathspec);
301 static int edit_patch(int argc, const char **argv, const char *prefix)
303 char *file = git_pathdup("ADD_EDIT.patch");
304 struct child_process child = CHILD_PROCESS_INIT;
305 struct rev_info rev;
306 int out;
307 struct stat st;
309 git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
311 if (read_cache() < 0)
312 die(_("Could not read the index"));
314 repo_init_revisions(the_repository, &rev, prefix);
315 rev.diffopt.context = 7;
317 argc = setup_revisions(argc, argv, &rev, NULL);
318 rev.diffopt.output_format = DIFF_FORMAT_PATCH;
319 rev.diffopt.use_color = 0;
320 rev.diffopt.flags.ignore_dirty_submodules = 1;
321 out = xopen(file, O_CREAT | O_WRONLY | O_TRUNC, 0666);
322 rev.diffopt.file = xfdopen(out, "w");
323 rev.diffopt.close_file = 1;
324 if (run_diff_files(&rev, 0))
325 die(_("Could not write patch"));
327 if (launch_editor(file, NULL, NULL))
328 die(_("editing patch failed"));
330 if (stat(file, &st))
331 die_errno(_("Could not stat '%s'"), file);
332 if (!st.st_size)
333 die(_("Empty patch. Aborted."));
335 child.git_cmd = 1;
336 strvec_pushl(&child.args, "apply", "--recount", "--cached", file,
337 NULL);
338 if (run_command(&child))
339 die(_("Could not apply '%s'"), file);
341 unlink(file);
342 free(file);
343 return 0;
346 static const char ignore_error[] =
347 N_("The following paths are ignored by one of your .gitignore files:\n");
349 static int verbose, show_only, ignored_too, refresh_only;
350 static int ignore_add_errors, intent_to_add, ignore_missing;
351 static int warn_on_embedded_repo = 1;
353 #define ADDREMOVE_DEFAULT 1
354 static int addremove = ADDREMOVE_DEFAULT;
355 static int addremove_explicit = -1; /* unspecified */
357 static char *chmod_arg;
359 static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
361 /* if we are told to ignore, we are not adding removals */
362 *(int *)opt->value = !unset ? 0 : 1;
363 return 0;
366 static struct option builtin_add_options[] = {
367 OPT__DRY_RUN(&show_only, N_("dry run")),
368 OPT__VERBOSE(&verbose, N_("be verbose")),
369 OPT_GROUP(""),
370 OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")),
371 OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")),
372 OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")),
373 OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files"), 0),
374 OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
375 OPT_BOOL(0, "renormalize", &add_renormalize, N_("renormalize EOL of tracked files (implies -u)")),
376 OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
377 OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
378 OPT_CALLBACK_F(0, "ignore-removal", &addremove_explicit,
379 NULL /* takes no arguments */,
380 N_("ignore paths removed in the working tree (same as --no-all)"),
381 PARSE_OPT_NOARG, ignore_removal_cb),
382 OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
383 OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
384 OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),
385 OPT_BOOL(0, "sparse", &include_sparse, N_("allow updating entries outside of the sparse-checkout cone")),
386 OPT_STRING(0, "chmod", &chmod_arg, "(+|-)x",
387 N_("override the executable bit of the listed files")),
388 OPT_HIDDEN_BOOL(0, "warn-embedded-repo", &warn_on_embedded_repo,
389 N_("warn when adding an embedded repository")),
390 OPT_PATHSPEC_FROM_FILE(&pathspec_from_file),
391 OPT_PATHSPEC_FILE_NUL(&pathspec_file_nul),
392 OPT_END(),
395 static int add_config(const char *var, const char *value, void *cb)
397 if (!strcmp(var, "add.ignoreerrors") ||
398 !strcmp(var, "add.ignore-errors")) {
399 ignore_add_errors = git_config_bool(var, value);
400 return 0;
403 return git_default_config(var, value, cb);
406 static const char embedded_advice[] = N_(
407 "You've added another git repository inside your current repository.\n"
408 "Clones of the outer repository will not contain the contents of\n"
409 "the embedded repository and will not know how to obtain it.\n"
410 "If you meant to add a submodule, use:\n"
411 "\n"
412 " git submodule add <url> %s\n"
413 "\n"
414 "If you added this path by mistake, you can remove it from the\n"
415 "index with:\n"
416 "\n"
417 " git rm --cached %s\n"
418 "\n"
419 "See \"git help submodule\" for more information."
422 static void check_embedded_repo(const char *path)
424 struct strbuf name = STRBUF_INIT;
425 static int adviced_on_embedded_repo = 0;
427 if (!warn_on_embedded_repo)
428 return;
429 if (!ends_with(path, "/"))
430 return;
432 /* Drop trailing slash for aesthetics */
433 strbuf_addstr(&name, path);
434 strbuf_strip_suffix(&name, "/");
436 warning(_("adding embedded git repository: %s"), name.buf);
437 if (!adviced_on_embedded_repo &&
438 advice_enabled(ADVICE_ADD_EMBEDDED_REPO)) {
439 advise(embedded_advice, name.buf, name.buf);
440 adviced_on_embedded_repo = 1;
443 strbuf_release(&name);
446 static int add_files(struct dir_struct *dir, int flags)
448 int i, exit_status = 0;
449 struct string_list matched_sparse_paths = STRING_LIST_INIT_NODUP;
451 if (dir->ignored_nr) {
452 fprintf(stderr, _(ignore_error));
453 for (i = 0; i < dir->ignored_nr; i++)
454 fprintf(stderr, "%s\n", dir->ignored[i]->name);
455 if (advice_enabled(ADVICE_ADD_IGNORED_FILE))
456 advise(_("Use -f if you really want to add them.\n"
457 "Turn this message off by running\n"
458 "\"git config advice.addIgnoredFile false\""));
459 exit_status = 1;
462 for (i = 0; i < dir->nr; i++) {
463 if (!include_sparse &&
464 !path_in_sparse_checkout(dir->entries[i]->name, &the_index)) {
465 string_list_append(&matched_sparse_paths,
466 dir->entries[i]->name);
467 continue;
469 if (add_file_to_index(&the_index, dir->entries[i]->name, flags)) {
470 if (!ignore_add_errors)
471 die(_("adding files failed"));
472 exit_status = 1;
473 } else {
474 check_embedded_repo(dir->entries[i]->name);
478 if (matched_sparse_paths.nr) {
479 advise_on_updating_sparse_paths(&matched_sparse_paths);
480 exit_status = 1;
483 string_list_clear(&matched_sparse_paths, 0);
485 return exit_status;
488 int cmd_add(int argc, const char **argv, const char *prefix)
490 int exit_status = 0;
491 struct pathspec pathspec;
492 struct dir_struct dir = DIR_INIT;
493 int flags;
494 int add_new_files;
495 int require_pathspec;
496 char *seen = NULL;
497 struct lock_file lock_file = LOCK_INIT;
499 git_config(add_config, NULL);
501 argc = parse_options(argc, argv, prefix, builtin_add_options,
502 builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
503 if (patch_interactive)
504 add_interactive = 1;
505 if (add_interactive) {
506 if (show_only)
507 die(_("options '%s' and '%s' cannot be used together"), "--dry-run", "--interactive/--patch");
508 if (pathspec_from_file)
509 die(_("options '%s' and '%s' cannot be used together"), "--pathspec-from-file", "--interactive/--patch");
510 exit(interactive_add(argv + 1, prefix, patch_interactive));
513 if (edit_interactive) {
514 if (pathspec_from_file)
515 die(_("options '%s' and '%s' cannot be used together"), "--pathspec-from-file", "--edit");
516 return(edit_patch(argc, argv, prefix));
518 argc--;
519 argv++;
521 if (0 <= addremove_explicit)
522 addremove = addremove_explicit;
523 else if (take_worktree_changes && ADDREMOVE_DEFAULT)
524 addremove = 0; /* "-u" was given but not "-A" */
526 if (addremove && take_worktree_changes)
527 die(_("options '%s' and '%s' cannot be used together"), "-A", "-u");
529 if (!show_only && ignore_missing)
530 die(_("the option '%s' requires '%s'"), "--ignore-missing", "--dry-run");
532 if (chmod_arg && ((chmod_arg[0] != '-' && chmod_arg[0] != '+') ||
533 chmod_arg[1] != 'x' || chmod_arg[2]))
534 die(_("--chmod param '%s' must be either -x or +x"), chmod_arg);
536 add_new_files = !take_worktree_changes && !refresh_only && !add_renormalize;
537 require_pathspec = !(take_worktree_changes || (0 < addremove_explicit));
539 prepare_repo_settings(the_repository);
540 the_repository->settings.command_requires_full_index = 0;
542 hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
545 * Check the "pathspec '%s' did not match any files" block
546 * below before enabling new magic.
548 parse_pathspec(&pathspec, PATHSPEC_ATTR,
549 PATHSPEC_PREFER_FULL |
550 PATHSPEC_SYMLINK_LEADING_PATH,
551 prefix, argv);
553 if (pathspec_from_file) {
554 if (pathspec.nr)
555 die(_("'%s' and pathspec arguments cannot be used together"), "--pathspec-from-file");
557 parse_pathspec_file(&pathspec, PATHSPEC_ATTR,
558 PATHSPEC_PREFER_FULL |
559 PATHSPEC_SYMLINK_LEADING_PATH,
560 prefix, pathspec_from_file, pathspec_file_nul);
561 } else if (pathspec_file_nul) {
562 die(_("the option '%s' requires '%s'"), "--pathspec-file-nul", "--pathspec-from-file");
565 if (require_pathspec && pathspec.nr == 0) {
566 fprintf(stderr, _("Nothing specified, nothing added.\n"));
567 if (advice_enabled(ADVICE_ADD_EMPTY_PATHSPEC))
568 advise( _("Maybe you wanted to say 'git add .'?\n"
569 "Turn this message off by running\n"
570 "\"git config advice.addEmptyPathspec false\""));
571 return 0;
574 if (!take_worktree_changes && addremove_explicit < 0 && pathspec.nr)
575 /* Turn "git add pathspec..." to "git add -A pathspec..." */
576 addremove = 1;
578 flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
579 (show_only ? ADD_CACHE_PRETEND : 0) |
580 (intent_to_add ? ADD_CACHE_INTENT : 0) |
581 (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
582 (!(addremove || take_worktree_changes)
583 ? ADD_CACHE_IGNORE_REMOVAL : 0));
585 if (read_cache_preload(&pathspec) < 0)
586 die(_("index file corrupt"));
588 die_in_unpopulated_submodule(&the_index, prefix);
589 die_path_inside_submodule(&the_index, &pathspec);
591 if (add_new_files) {
592 int baselen;
594 /* Set up the default git porcelain excludes */
595 if (!ignored_too) {
596 dir.flags |= DIR_COLLECT_IGNORED;
597 setup_standard_excludes(&dir);
600 /* This picks up the paths that are not tracked */
601 baselen = fill_directory(&dir, &the_index, &pathspec);
602 if (pathspec.nr)
603 seen = prune_directory(&dir, &pathspec, baselen);
606 if (refresh_only) {
607 exit_status |= refresh(verbose, &pathspec);
608 goto finish;
611 if (pathspec.nr) {
612 int i;
613 char *skip_worktree_seen = NULL;
614 struct string_list only_match_skip_worktree = STRING_LIST_INIT_NODUP;
616 if (!seen)
617 seen = find_pathspecs_matching_against_index(&pathspec,
618 &the_index, PS_IGNORE_SKIP_WORKTREE);
621 * file_exists() assumes exact match
623 GUARD_PATHSPEC(&pathspec,
624 PATHSPEC_FROMTOP |
625 PATHSPEC_LITERAL |
626 PATHSPEC_GLOB |
627 PATHSPEC_ICASE |
628 PATHSPEC_EXCLUDE);
630 for (i = 0; i < pathspec.nr; i++) {
631 const char *path = pathspec.items[i].match;
633 if (pathspec.items[i].magic & PATHSPEC_EXCLUDE)
634 continue;
635 if (seen[i])
636 continue;
638 if (!include_sparse &&
639 matches_skip_worktree(&pathspec, i, &skip_worktree_seen)) {
640 string_list_append(&only_match_skip_worktree,
641 pathspec.items[i].original);
642 continue;
645 /* Don't complain at 'git add .' on empty repo */
646 if (!path[0])
647 continue;
649 if ((pathspec.items[i].magic & (PATHSPEC_GLOB | PATHSPEC_ICASE)) ||
650 !file_exists(path)) {
651 if (ignore_missing) {
652 int dtype = DT_UNKNOWN;
653 if (is_excluded(&dir, &the_index, path, &dtype))
654 dir_add_ignored(&dir, &the_index,
655 path, pathspec.items[i].len);
656 } else
657 die(_("pathspec '%s' did not match any files"),
658 pathspec.items[i].original);
663 if (only_match_skip_worktree.nr) {
664 advise_on_updating_sparse_paths(&only_match_skip_worktree);
665 exit_status = 1;
668 free(seen);
669 free(skip_worktree_seen);
670 string_list_clear(&only_match_skip_worktree, 0);
673 plug_bulk_checkin();
675 if (add_renormalize)
676 exit_status |= renormalize_tracked_files(&pathspec, flags);
677 else
678 exit_status |= add_files_to_cache(prefix, &pathspec, flags);
680 if (add_new_files)
681 exit_status |= add_files(&dir, flags);
683 if (chmod_arg && pathspec.nr)
684 exit_status |= chmod_pathspec(&pathspec, chmod_arg[0], show_only);
685 unplug_bulk_checkin();
687 finish:
688 if (write_locked_index(&the_index, &lock_file,
689 COMMIT_LOCK | SKIP_IF_UNCHANGED))
690 die(_("Unable to write new index file"));
692 dir_clear(&dir);
693 UNLEAK(pathspec);
694 return exit_status;