convert run_add_interactive to use struct pathspec
[git/git.git] / builtin / add.c
CommitLineData
0d781539
LT
1/*
2 * "git add" builtin command
3 *
4 * Copyright (C) 2006 Linus Torvalds
5 */
0d781539
LT
6#include "cache.h"
7#include "builtin.h"
8#include "dir.h"
6f525e71 9#include "pathspec.h"
5cde71d6 10#include "exec_cmd.h"
93872e07 11#include "cache-tree.h"
58680165 12#include "run-command.h"
5c46f754 13#include "parse-options.h"
c59cb03a 14#include "diff.h"
fb7d3f32 15#include "diffcore.h"
c59cb03a 16#include "revision.h"
568508e7 17#include "bulk-checkin.h"
0d781539 18
5c46f754 19static const char * const builtin_add_usage[] = {
d32805dc 20 N_("git add [options] [--] <pathspec>..."),
5c46f754
KH
21 NULL
22};
c59cb03a 23static int patch_interactive, add_interactive, edit_interactive;
93c44d49 24static int take_worktree_changes;
896bdfa2 25
9cba13ca 26struct update_callback_data {
fb7d3f32
LT
27 int flags;
28 int add_errors;
71c7b053
JN
29 const char *implicit_dot;
30 size_t implicit_dot_len;
d226b14d
JH
31
32 /* only needed for 2.0 transition preparation */
33 int warn_add_would_remove;
fb7d3f32
LT
34};
35
e24afab0
JN
36static const char *option_with_implicit_dot;
37static const char *short_option_with_implicit_dot;
38
39static void warn_pathless_add(void)
40{
16d41d42 41 static int shown;
e24afab0
JN
42 assert(option_with_implicit_dot && short_option_with_implicit_dot);
43
16d41d42
JN
44 if (shown)
45 return;
46 shown = 1;
47
e24afab0
JN
48 /*
49 * To be consistent with "git add -p" and most Git
50 * commands, we should default to being tree-wide, but
51 * this is not the original behavior and can't be
52 * changed until users trained themselves not to type
53 * "git add -u" or "git add -A". For now, we warn and
54 * keep the old behavior. Later, the behavior can be changed
55 * to tree-wide, keeping the warning for a while, and
56 * eventually we can drop the warning.
57 */
58 warning(_("The behavior of 'git add %s (or %s)' with no path argument from a\n"
59 "subdirectory of the tree will change in Git 2.0 and should not be used anymore.\n"
60 "To add content for the whole tree, run:\n"
61 "\n"
62 " git add %s :/\n"
63 " (or git add %s :/)\n"
64 "\n"
65 "To restrict the command to the current directory, run:\n"
66 "\n"
67 " git add %s .\n"
68 " (or git add %s .)\n"
69 "\n"
c9f35b8b
MM
70 "With the current Git version, the command is restricted to "
71 "the current directory.\n"
72 ""),
e24afab0
JN
73 option_with_implicit_dot, short_option_with_implicit_dot,
74 option_with_implicit_dot, short_option_with_implicit_dot,
75 option_with_implicit_dot, short_option_with_implicit_dot);
76}
77
75973b2c
JH
78static int fix_unmerged_status(struct diff_filepair *p,
79 struct update_callback_data *data)
80{
81 if (p->status != DIFF_STATUS_UNMERGED)
82 return p->status;
83 if (!(data->flags & ADD_CACHE_IGNORE_REMOVAL) && !p->two->mode)
84 /*
85 * This is not an explicit add request, and the
86 * path is missing from the working tree (deleted)
87 */
88 return DIFF_STATUS_DELETED;
89 else
90 /*
91 * Either an explicit add request, or path exists
92 * in the working tree. An attempt to explicitly
93 * add a path that does not exist in the working tree
94 * will be caught as an error by the caller immediately.
95 */
96 return DIFF_STATUS_MODIFIED;
97}
98
ccc663bc 99static const char *add_would_remove_warning = N_(
4c711430
JH
100 "You ran 'git add' with neither '-A (--all)' or '--ignore-removal',\n"
101"whose behaviour will change in Git 2.0 with respect to paths you removed.\n"
102"Paths like '%s' that are\n"
103"removed from your working tree are ignored with this version of Git.\n"
ccc663bc 104"\n"
4c711430
JH
105"* 'git add --ignore-removal <pathspec>', which is the current default,\n"
106" ignores paths you removed from your working tree.\n"
ccc663bc
JH
107"\n"
108"* 'git add --all <pathspec>' will let you also record the removals.\n"
109"\n"
110"Run 'git status' to check the paths you removed from your working tree.\n");
111
d226b14d
JH
112static void warn_add_would_remove(const char *path)
113{
ccc663bc 114 warning(_(add_would_remove_warning), path);
d226b14d
JH
115}
116
fb7d3f32
LT
117static void update_callback(struct diff_queue_struct *q,
118 struct diff_options *opt, void *cbdata)
119{
120 int i;
121 struct update_callback_data *data = cbdata;
71c7b053
JN
122 const char *implicit_dot = data->implicit_dot;
123 size_t implicit_dot_len = data->implicit_dot_len;
fb7d3f32
LT
124
125 for (i = 0; i < q->nr; i++) {
126 struct diff_filepair *p = q->queue[i];
127 const char *path = p->one->path;
71c7b053
JN
128 /*
129 * Check if "git add -A" or "git add -u" was run from a
130 * subdirectory with a modified file outside that directory,
131 * and warn if so.
132 *
133 * "git add -u" will behave like "git add -u :/" instead of
134 * "git add -u ." in the future. This warning prepares for
135 * that change.
136 */
137 if (implicit_dot &&
138 strncmp_icase(path, implicit_dot, implicit_dot_len)) {
139 warn_pathless_add();
140 continue;
141 }
75973b2c 142 switch (fix_unmerged_status(p, data)) {
fb7d3f32 143 default:
990ac4be 144 die(_("unexpected diff status %c"), p->status);
fb7d3f32
LT
145 case DIFF_STATUS_MODIFIED:
146 case DIFF_STATUS_TYPE_CHANGED:
147 if (add_file_to_index(&the_index, path, data->flags)) {
148 if (!(data->flags & ADD_CACHE_IGNORE_ERRORS))
990ac4be 149 die(_("updating files failed"));
fb7d3f32
LT
150 data->add_errors++;
151 }
152 break;
153 case DIFF_STATUS_DELETED:
d226b14d
JH
154 if (data->warn_add_would_remove) {
155 warn_add_would_remove(path);
156 data->warn_add_would_remove = 0;
157 }
fb7d3f32
LT
158 if (data->flags & ADD_CACHE_IGNORE_REMOVAL)
159 break;
160 if (!(data->flags & ADD_CACHE_PRETEND))
161 remove_file_from_index(&the_index, path);
162 if (data->flags & (ADD_CACHE_PRETEND|ADD_CACHE_VERBOSE))
475c73eb 163 printf(_("remove '%s'\n"), path);
fb7d3f32
LT
164 break;
165 }
166 }
167}
168
d226b14d
JH
169static void update_files_in_cache(const char *prefix, const char **pathspec,
170 struct update_callback_data *data)
fb7d3f32 171{
fb7d3f32 172 struct rev_info rev;
71c7b053 173
fb7d3f32
LT
174 init_revisions(&rev, prefix);
175 setup_revisions(0, NULL, &rev, NULL);
afe069d1 176 init_pathspec(&rev.prune_data, pathspec);
fb7d3f32
LT
177 rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
178 rev.diffopt.format_callback = update_callback;
d226b14d 179 rev.diffopt.format_callback_data = data;
75973b2c 180 rev.max_count = 0; /* do not compare unmerged paths with stage #2 */
fb7d3f32 181 run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);
d226b14d
JH
182}
183
184int add_files_to_cache(const char *prefix, const char **pathspec, int flags)
185{
186 struct update_callback_data data;
187
188 memset(&data, 0, sizeof(data));
189 data.flags = flags;
190 update_files_in_cache(prefix, pathspec, &data);
fb7d3f32
LT
191 return !!data.add_errors;
192}
193
9df84e94
JN
194#define WARN_IMPLICIT_DOT (1u << 0)
195static char *prune_directory(struct dir_struct *dir, const char **pathspec,
196 int prefix, unsigned flag)
0d781539 197{
f2593398
LT
198 char *seen;
199 int i, specs;
0d781539
LT
200 struct dir_entry **src, **dst;
201
f2593398
LT
202 for (specs = 0; pathspec[specs]; specs++)
203 /* nothing */;
28f75818 204 seen = xcalloc(specs, 1);
f2593398 205
0d781539
LT
206 src = dst = dir->entries;
207 i = dir->nr;
208 while (--i >= 0) {
209 struct dir_entry *entry = *src++;
4d06f8ac
JH
210 if (match_pathspec(pathspec, entry->name, entry->len,
211 prefix, seen))
212 *dst++ = entry;
9df84e94
JN
213 else if (flag & WARN_IMPLICIT_DOT)
214 /*
215 * "git add -A" was run from a subdirectory with a
216 * new file outside that directory.
217 *
218 * "git add -A" will behave like "git add -A :/"
219 * instead of "git add -A ." in the future.
220 * Warn about the coming behavior change.
221 */
222 warn_pathless_add();
0d781539
LT
223 }
224 dir->nr = dst - dir->entries;
4b78d7bc 225 add_pathspec_matches_against_index(pathspec, seen, specs);
81f45e7d 226 return seen;
0d781539
LT
227}
228
d616813d
AJ
229static void refresh(int verbose, const char **pathspec)
230{
231 char *seen;
232 int i, specs;
233
234 for (specs = 0; pathspec[specs]; specs++)
235 /* nothing */;
236 seen = xcalloc(specs, 1);
43673fdd 237 refresh_index(&the_index, verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET,
ed2a808d 238 pathspec, seen, _("Unstaged changes after refreshing the index:"));
d616813d
AJ
239 for (i = 0; i < specs; i++) {
240 if (!seen[i])
990ac4be 241 die(_("pathspec '%s' did not match any files"), pathspec[i]);
d616813d 242 }
399f0a8e 243 free(seen);
d616813d
AJ
244}
245
46b5139c 246int run_add_interactive(const char *revision, const char *patch_mode,
480ca644 247 const struct pathspec *pathspec)
58680165 248{
480ca644 249 int status, ac, i;
3f061887 250 const char **args;
3f061887 251
480ca644 252 args = xcalloc(sizeof(const char *), (pathspec->nr + 6));
b63e9950
WC
253 ac = 0;
254 args[ac++] = "add--interactive";
46b5139c
TR
255 if (patch_mode)
256 args[ac++] = patch_mode;
257 if (revision)
258 args[ac++] = revision;
b63e9950 259 args[ac++] = "--";
480ca644
NTND
260 for (i = 0; i < pathspec->nr; i++)
261 /* pass original pathspec, to be re-parsed */
262 args[ac++] = pathspec->items[i].original;
7c0ab445
WC
263
264 status = run_command_v_opt(args, RUN_GIT_CMD);
265 free(args);
266 return status;
58680165
KH
267}
268
b4bd4668 269int interactive_add(int argc, const char **argv, const char *prefix, int patch)
46b5139c 270{
5a76aff1 271 struct pathspec pathspec;
46b5139c 272
5a76aff1
NTND
273 /*
274 * git-add--interactive itself does not parse pathspec. It
275 * simply passes the pathspec to other builtin commands. Let's
276 * hope all of them support all magic, or we'll need to limit
480ca644 277 * the magic here.
5a76aff1
NTND
278 */
279 parse_pathspec(&pathspec, PATHSPEC_ALL_MAGIC & ~PATHSPEC_FROMTOP,
280 PATHSPEC_PREFER_FULL |
480ca644
NTND
281 PATHSPEC_SYMLINK_LEADING_PATH |
282 PATHSPEC_PREFIX_ORIGIN,
5a76aff1 283 prefix, argv);
46b5139c
TR
284
285 return run_add_interactive(NULL,
b4bd4668 286 patch ? "--patch" : NULL,
480ca644 287 &pathspec);
46b5139c
TR
288}
289
2af202be 290static int edit_patch(int argc, const char **argv, const char *prefix)
c59cb03a 291{
d292bfaf 292 char *file = git_pathdup("ADD_EDIT.patch");
c59cb03a 293 const char *apply_argv[] = { "apply", "--recount", "--cached",
66dbfd55 294 NULL, NULL };
c59cb03a
JS
295 struct child_process child;
296 struct rev_info rev;
297 int out;
298 struct stat st;
299
66dbfd55
GV
300 apply_argv[3] = file;
301
c59cb03a
JS
302 git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
303
304 if (read_cache() < 0)
990ac4be 305 die (_("Could not read the index"));
c59cb03a
JS
306
307 init_revisions(&rev, prefix);
308 rev.diffopt.context = 7;
309
310 argc = setup_revisions(argc, argv, &rev, NULL);
311 rev.diffopt.output_format = DIFF_FORMAT_PATCH;
701825de 312 DIFF_OPT_SET(&rev.diffopt, IGNORE_DIRTY_SUBMODULES);
6ff2b729 313 out = open(file, O_CREAT | O_WRONLY, 0666);
c59cb03a 314 if (out < 0)
990ac4be 315 die (_("Could not open '%s' for writing."), file);
41698375 316 rev.diffopt.file = xfdopen(out, "w");
c59cb03a
JS
317 rev.diffopt.close_file = 1;
318 if (run_diff_files(&rev, 0))
990ac4be 319 die (_("Could not write patch"));
c59cb03a
JS
320
321 launch_editor(file, NULL, NULL);
322
323 if (stat(file, &st))
990ac4be 324 die_errno(_("Could not stat '%s'"), file);
c59cb03a 325 if (!st.st_size)
990ac4be 326 die(_("Empty patch. Aborted."));
c59cb03a
JS
327
328 memset(&child, 0, sizeof(child));
329 child.git_cmd = 1;
330 child.argv = apply_argv;
331 if (run_command(&child))
990ac4be 332 die (_("Could not apply '%s'"), file);
c59cb03a
JS
333
334 unlink(file);
d292bfaf 335 free(file);
c59cb03a
JS
336 return 0;
337}
338
021b6e45 339static struct lock_file lock_file;
0d781539 340
b39c53e6 341static const char ignore_error[] =
439fb829 342N_("The following paths are ignored by one of your .gitignore files:\n");
6a1ad325 343
300c0a22 344static int verbose, show_only, ignored_too, refresh_only;
45c45e30
JH
345static int ignore_add_errors, intent_to_add, ignore_missing;
346
347#define ADDREMOVE_DEFAULT 0 /* Change to 1 in Git 2.0 */
348static int addremove = ADDREMOVE_DEFAULT;
349static int addremove_explicit = -1; /* unspecified */
5c46f754 350
9f60f49b
JH
351static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
352{
353 /* if we are told to ignore, we are not adding removals */
354 *(int *)opt->value = !unset ? 0 : 1;
355 return 0;
356}
357
5c46f754 358static struct option builtin_add_options[] = {
1b56024c
NTND
359 OPT__DRY_RUN(&show_only, N_("dry run")),
360 OPT__VERBOSE(&verbose, N_("be verbose")),
5c46f754 361 OPT_GROUP(""),
300c0a22
JH
362 OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")),
363 OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")),
364 OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")),
1b56024c 365 OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files")),
300c0a22
JH
366 OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
367 OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
45c45e30 368 OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
9f60f49b
JH
369 { OPTION_CALLBACK, 0, "ignore-removal", &addremove_explicit,
370 NULL /* takes no arguments */,
371 N_("ignore paths removed in the working tree (same as --no-all)"),
372 PARSE_OPT_NOARG, ignore_removal_cb },
300c0a22
JH
373 OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
374 OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
375 OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),
5c46f754
KH
376 OPT_END(),
377};
378
9bd81e42 379static int add_config(const char *var, const char *value, void *cb)
dad25e4a 380{
8c2be75f
JN
381 if (!strcmp(var, "add.ignoreerrors") ||
382 !strcmp(var, "add.ignore-errors")) {
dad25e4a
AR
383 ignore_add_errors = git_config_bool(var, value);
384 return 0;
385 }
9bd81e42 386 return git_default_config(var, value, cb);
dad25e4a
AR
387}
388
c972ec04
JH
389static int add_files(struct dir_struct *dir, int flags)
390{
391 int i, exit_status = 0;
392
393 if (dir->ignored_nr) {
439fb829 394 fprintf(stderr, _(ignore_error));
c972ec04
JH
395 for (i = 0; i < dir->ignored_nr; i++)
396 fprintf(stderr, "%s\n", dir->ignored[i]->name);
439fb829
ÆAB
397 fprintf(stderr, _("Use -f if you really want to add them.\n"));
398 die(_("no files added"));
c972ec04
JH
399 }
400
401 for (i = 0; i < dir->nr; i++)
402 if (add_file_to_cache(dir->entries[i]->name, flags)) {
403 if (!ignore_add_errors)
990ac4be 404 die(_("adding files failed"));
c972ec04
JH
405 exit_status = 1;
406 }
407 return exit_status;
408}
409
a633fca0 410int cmd_add(int argc, const char **argv, const char *prefix)
0d781539 411{
7ae02a30 412 int exit_status = 0;
c972ec04 413 int newfd;
5a76aff1 414 struct pathspec pathspec;
0d781539 415 struct dir_struct dir;
205ffa94 416 int flags;
c972ec04
JH
417 int add_new_files;
418 int require_pathspec;
81f45e7d 419 char *seen = NULL;
71c7b053 420 int implicit_dot = 0;
d226b14d 421 struct update_callback_data update_data;
5cde71d6 422
ed342fde
SB
423 git_config(add_config, NULL);
424
37782920 425 argc = parse_options(argc, argv, prefix, builtin_add_options,
c59cb03a 426 builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
b63e9950
WC
427 if (patch_interactive)
428 add_interactive = 1;
7c0ab445 429 if (add_interactive)
b4bd4668 430 exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
0d781539 431
c59cb03a
JS
432 if (edit_interactive)
433 return(edit_patch(argc, argv, prefix));
434 argc--;
435 argv++;
436
45c45e30
JH
437 if (0 <= addremove_explicit)
438 addremove = addremove_explicit;
439 else if (take_worktree_changes && ADDREMOVE_DEFAULT)
440 addremove = 0; /* "-u" was given but not "-A" */
441
3ba1f114 442 if (addremove && take_worktree_changes)
990ac4be 443 die(_("-A and -u are mutually incompatible"));
45c45e30
JH
444
445 /*
446 * Warn when "git add pathspec..." was given without "-u" or "-A"
d226b14d 447 * and pathspec... covers a removed path.
45c45e30 448 */
d226b14d
JH
449 memset(&update_data, 0, sizeof(update_data));
450 if (!take_worktree_changes && addremove_explicit < 0)
451 update_data.warn_add_would_remove = 1;
45c45e30
JH
452
453 if (!take_worktree_changes && addremove_explicit < 0 && argc)
454 /*
455 * Turn "git add pathspec..." to "git add -A pathspec..."
456 * in Git 2.0 but not yet
457 */
458 ; /* addremove = 1; */
459
108da0db 460 if (!show_only && ignore_missing)
990ac4be 461 die(_("Option --ignore-missing can only be used together with --dry-run"));
0fa2eb53
MM
462 if (addremove) {
463 option_with_implicit_dot = "--all";
464 short_option_with_implicit_dot = "-A";
465 }
466 if (take_worktree_changes) {
467 option_with_implicit_dot = "--update";
468 short_option_with_implicit_dot = "-u";
469 }
470 if (option_with_implicit_dot && !argc) {
3ba1f114
JH
471 static const char *here[2] = { ".", NULL };
472 argc = 1;
473 argv = here;
71c7b053 474 implicit_dot = 1;
3ba1f114
JH
475 }
476
c972ec04
JH
477 add_new_files = !take_worktree_changes && !refresh_only;
478 require_pathspec = !take_worktree_changes;
479
30ca07a2 480 newfd = hold_locked_index(&lock_file, 1);
0d781539 481
205ffa94 482 flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
01665924 483 (show_only ? ADD_CACHE_PRETEND : 0) |
39425819 484 (intent_to_add ? ADD_CACHE_INTENT : 0) |
1e5f764c
JH
485 (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
486 (!(addremove || take_worktree_changes)
71c7b053
JN
487 ? ADD_CACHE_IGNORE_REMOVAL : 0)) |
488 (implicit_dot ? ADD_CACHE_IMPLICIT_DOT : 0);
205ffa94 489
c972ec04 490 if (require_pathspec && argc == 0) {
990ac4be
ÆAB
491 fprintf(stderr, _("Nothing specified, nothing added.\n"));
492 fprintf(stderr, _("Maybe you wanted to say 'git add .'?\n"));
93b0d86a
JH
493 return 0;
494 }
0d781539 495
366bfcb6 496 if (read_cache() < 0)
990ac4be 497 die(_("index file corrupt"));
5a76aff1
NTND
498
499 /*
500 * Check the "pathspec '%s' did not match any files" block
501 * below before enabling new magic.
502 */
503 parse_pathspec(&pathspec, 0,
504 PATHSPEC_PREFER_FULL |
505 PATHSPEC_SYMLINK_LEADING_PATH |
506 PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE,
507 prefix, argv);
366bfcb6 508
1d8842d9
LT
509 if (add_new_files) {
510 int baselen;
511
512 /* Set up the default git porcelain excludes */
513 memset(&dir, 0, sizeof(dir));
514 if (!ignored_too) {
515 dir.flags |= DIR_COLLECT_IGNORED;
516 setup_standard_excludes(&dir);
517 }
518
1e5f764c 519 /* This picks up the paths that are not tracked */
5a76aff1
NTND
520 baselen = fill_directory(&dir, implicit_dot ? NULL : pathspec.raw);
521 if (pathspec.nr)
522 seen = prune_directory(&dir, pathspec.raw, baselen,
9df84e94 523 implicit_dot ? WARN_IMPLICIT_DOT : 0);
1d8842d9 524 }
1e5f764c 525
c972ec04 526 if (refresh_only) {
5a76aff1 527 refresh(verbose, pathspec.raw);
c972ec04 528 goto finish;
6a1ad325 529 }
0df7b8e5
JH
530 if (implicit_dot && prefix)
531 refresh_cache(REFRESH_QUIET);
6a1ad325 532
5a76aff1 533 if (pathspec.nr) {
81f45e7d 534 int i;
eb69934b 535
81f45e7d 536 if (!seen)
5a76aff1
NTND
537 seen = find_pathspecs_matching_against_index(pathspec.raw);
538
539 /*
540 * file_exists() assumes exact match
541 */
542 GUARD_PATHSPEC(&pathspec, PATHSPEC_FROMTOP);
543
544 for (i = 0; pathspec.raw[i]; i++) {
545 if (!seen[i] && pathspec.raw[i][0]
546 && !file_exists(pathspec.raw[i])) {
108da0db 547 if (ignore_missing) {
0188f6b3 548 int dtype = DT_UNKNOWN;
5a76aff1
NTND
549 if (is_excluded(&dir, pathspec.raw[i], &dtype))
550 dir_add_ignored(&dir, pathspec.raw[i], strlen(pathspec.raw[i]));
108da0db 551 } else
48168851 552 die(_("pathspec '%s' did not match any files"),
5a76aff1 553 pathspec.raw[i]);
108da0db 554 }
81f45e7d
JH
555 }
556 free(seen);
557 }
558
568508e7
JH
559 plug_bulk_checkin();
560
561954bf
JH
561 if ((flags & ADD_CACHE_IMPLICIT_DOT) && prefix) {
562 /*
563 * Check for modified files throughout the worktree so
564 * update_callback has a chance to warn about changes
565 * outside the cwd.
566 */
567 update_data.implicit_dot = prefix;
568 update_data.implicit_dot_len = strlen(prefix);
5a76aff1
NTND
569 free_pathspec(&pathspec);
570 memset(&pathspec, 0, sizeof(pathspec));
561954bf
JH
571 }
572 update_data.flags = flags & ~ADD_CACHE_IMPLICIT_DOT;
5a76aff1 573 update_files_in_cache(prefix, pathspec.raw, &update_data);
c972ec04 574
d226b14d 575 exit_status |= !!update_data.add_errors;
c972ec04
JH
576 if (add_new_files)
577 exit_status |= add_files(&dir, flags);
0d781539 578
568508e7
JH
579 unplug_bulk_checkin();
580
dfdac5d9 581 finish:
0d781539
LT
582 if (active_cache_changed) {
583 if (write_cache(newfd, active_cache, active_nr) ||
4ed7cd3a 584 commit_locked_index(&lock_file))
990ac4be 585 die(_("Unable to write new index file"));
0d781539
LT
586 }
587
7ae02a30 588 return exit_status;
0d781539 589}