convert add_files_to_cache to take 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
3efe8e43
NTND
169static void update_files_in_cache(const char *prefix,
170 const struct pathspec *pathspec,
d226b14d 171 struct update_callback_data *data)
fb7d3f32 172{
fb7d3f32 173 struct rev_info rev;
71c7b053 174
fb7d3f32
LT
175 init_revisions(&rev, prefix);
176 setup_revisions(0, NULL, &rev, NULL);
3efe8e43
NTND
177 if (pathspec)
178 copy_pathspec(&rev.prune_data, pathspec);
fb7d3f32
LT
179 rev.diffopt.output_format = DIFF_FORMAT_CALLBACK;
180 rev.diffopt.format_callback = update_callback;
d226b14d 181 rev.diffopt.format_callback_data = data;
75973b2c 182 rev.max_count = 0; /* do not compare unmerged paths with stage #2 */
fb7d3f32 183 run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);
d226b14d
JH
184}
185
3efe8e43
NTND
186int add_files_to_cache(const char *prefix,
187 const struct pathspec *pathspec, int flags)
d226b14d
JH
188{
189 struct update_callback_data data;
190
191 memset(&data, 0, sizeof(data));
192 data.flags = flags;
193 update_files_in_cache(prefix, pathspec, &data);
fb7d3f32
LT
194 return !!data.add_errors;
195}
196
9df84e94
JN
197#define WARN_IMPLICIT_DOT (1u << 0)
198static char *prune_directory(struct dir_struct *dir, const char **pathspec,
199 int prefix, unsigned flag)
0d781539 200{
f2593398
LT
201 char *seen;
202 int i, specs;
0d781539
LT
203 struct dir_entry **src, **dst;
204
f2593398
LT
205 for (specs = 0; pathspec[specs]; specs++)
206 /* nothing */;
28f75818 207 seen = xcalloc(specs, 1);
f2593398 208
0d781539
LT
209 src = dst = dir->entries;
210 i = dir->nr;
211 while (--i >= 0) {
212 struct dir_entry *entry = *src++;
4d06f8ac
JH
213 if (match_pathspec(pathspec, entry->name, entry->len,
214 prefix, seen))
215 *dst++ = entry;
9df84e94
JN
216 else if (flag & WARN_IMPLICIT_DOT)
217 /*
218 * "git add -A" was run from a subdirectory with a
219 * new file outside that directory.
220 *
221 * "git add -A" will behave like "git add -A :/"
222 * instead of "git add -A ." in the future.
223 * Warn about the coming behavior change.
224 */
225 warn_pathless_add();
0d781539
LT
226 }
227 dir->nr = dst - dir->entries;
4b78d7bc 228 add_pathspec_matches_against_index(pathspec, seen, specs);
81f45e7d 229 return seen;
0d781539
LT
230}
231
9b2d6149 232static void refresh(int verbose, const struct pathspec *pathspec)
d616813d
AJ
233{
234 char *seen;
9b2d6149 235 int i;
d616813d 236
9b2d6149 237 seen = xcalloc(pathspec->nr, 1);
43673fdd 238 refresh_index(&the_index, verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET,
ed2a808d 239 pathspec, seen, _("Unstaged changes after refreshing the index:"));
9b2d6149 240 for (i = 0; i < pathspec->nr; i++) {
d616813d 241 if (!seen[i])
9b2d6149
NTND
242 die(_("pathspec '%s' did not match any files"),
243 pathspec->items[i].match);
d616813d 244 }
399f0a8e 245 free(seen);
d616813d
AJ
246}
247
46b5139c 248int run_add_interactive(const char *revision, const char *patch_mode,
480ca644 249 const struct pathspec *pathspec)
58680165 250{
480ca644 251 int status, ac, i;
3f061887 252 const char **args;
3f061887 253
480ca644 254 args = xcalloc(sizeof(const char *), (pathspec->nr + 6));
b63e9950
WC
255 ac = 0;
256 args[ac++] = "add--interactive";
46b5139c
TR
257 if (patch_mode)
258 args[ac++] = patch_mode;
259 if (revision)
260 args[ac++] = revision;
b63e9950 261 args[ac++] = "--";
480ca644
NTND
262 for (i = 0; i < pathspec->nr; i++)
263 /* pass original pathspec, to be re-parsed */
264 args[ac++] = pathspec->items[i].original;
7c0ab445
WC
265
266 status = run_command_v_opt(args, RUN_GIT_CMD);
267 free(args);
268 return status;
58680165
KH
269}
270
b4bd4668 271int interactive_add(int argc, const char **argv, const char *prefix, int patch)
46b5139c 272{
5a76aff1 273 struct pathspec pathspec;
46b5139c 274
5a76aff1
NTND
275 /*
276 * git-add--interactive itself does not parse pathspec. It
277 * simply passes the pathspec to other builtin commands. Let's
278 * hope all of them support all magic, or we'll need to limit
480ca644 279 * the magic here.
5a76aff1
NTND
280 */
281 parse_pathspec(&pathspec, PATHSPEC_ALL_MAGIC & ~PATHSPEC_FROMTOP,
282 PATHSPEC_PREFER_FULL |
480ca644
NTND
283 PATHSPEC_SYMLINK_LEADING_PATH |
284 PATHSPEC_PREFIX_ORIGIN,
5a76aff1 285 prefix, argv);
46b5139c
TR
286
287 return run_add_interactive(NULL,
b4bd4668 288 patch ? "--patch" : NULL,
480ca644 289 &pathspec);
46b5139c
TR
290}
291
2af202be 292static int edit_patch(int argc, const char **argv, const char *prefix)
c59cb03a 293{
d292bfaf 294 char *file = git_pathdup("ADD_EDIT.patch");
c59cb03a 295 const char *apply_argv[] = { "apply", "--recount", "--cached",
66dbfd55 296 NULL, NULL };
c59cb03a
JS
297 struct child_process child;
298 struct rev_info rev;
299 int out;
300 struct stat st;
301
66dbfd55
GV
302 apply_argv[3] = file;
303
c59cb03a
JS
304 git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
305
306 if (read_cache() < 0)
990ac4be 307 die (_("Could not read the index"));
c59cb03a
JS
308
309 init_revisions(&rev, prefix);
310 rev.diffopt.context = 7;
311
312 argc = setup_revisions(argc, argv, &rev, NULL);
313 rev.diffopt.output_format = DIFF_FORMAT_PATCH;
701825de 314 DIFF_OPT_SET(&rev.diffopt, IGNORE_DIRTY_SUBMODULES);
6ff2b729 315 out = open(file, O_CREAT | O_WRONLY, 0666);
c59cb03a 316 if (out < 0)
990ac4be 317 die (_("Could not open '%s' for writing."), file);
41698375 318 rev.diffopt.file = xfdopen(out, "w");
c59cb03a
JS
319 rev.diffopt.close_file = 1;
320 if (run_diff_files(&rev, 0))
990ac4be 321 die (_("Could not write patch"));
c59cb03a
JS
322
323 launch_editor(file, NULL, NULL);
324
325 if (stat(file, &st))
990ac4be 326 die_errno(_("Could not stat '%s'"), file);
c59cb03a 327 if (!st.st_size)
990ac4be 328 die(_("Empty patch. Aborted."));
c59cb03a
JS
329
330 memset(&child, 0, sizeof(child));
331 child.git_cmd = 1;
332 child.argv = apply_argv;
333 if (run_command(&child))
990ac4be 334 die (_("Could not apply '%s'"), file);
c59cb03a
JS
335
336 unlink(file);
d292bfaf 337 free(file);
c59cb03a
JS
338 return 0;
339}
340
021b6e45 341static struct lock_file lock_file;
0d781539 342
b39c53e6 343static const char ignore_error[] =
439fb829 344N_("The following paths are ignored by one of your .gitignore files:\n");
6a1ad325 345
300c0a22 346static int verbose, show_only, ignored_too, refresh_only;
45c45e30
JH
347static int ignore_add_errors, intent_to_add, ignore_missing;
348
349#define ADDREMOVE_DEFAULT 0 /* Change to 1 in Git 2.0 */
350static int addremove = ADDREMOVE_DEFAULT;
351static int addremove_explicit = -1; /* unspecified */
5c46f754 352
9f60f49b
JH
353static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
354{
355 /* if we are told to ignore, we are not adding removals */
356 *(int *)opt->value = !unset ? 0 : 1;
357 return 0;
358}
359
5c46f754 360static struct option builtin_add_options[] = {
1b56024c
NTND
361 OPT__DRY_RUN(&show_only, N_("dry run")),
362 OPT__VERBOSE(&verbose, N_("be verbose")),
5c46f754 363 OPT_GROUP(""),
300c0a22
JH
364 OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")),
365 OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")),
366 OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")),
1b56024c 367 OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files")),
300c0a22
JH
368 OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
369 OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
45c45e30 370 OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
9f60f49b
JH
371 { OPTION_CALLBACK, 0, "ignore-removal", &addremove_explicit,
372 NULL /* takes no arguments */,
373 N_("ignore paths removed in the working tree (same as --no-all)"),
374 PARSE_OPT_NOARG, ignore_removal_cb },
300c0a22
JH
375 OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
376 OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
377 OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),
5c46f754
KH
378 OPT_END(),
379};
380
9bd81e42 381static int add_config(const char *var, const char *value, void *cb)
dad25e4a 382{
8c2be75f
JN
383 if (!strcmp(var, "add.ignoreerrors") ||
384 !strcmp(var, "add.ignore-errors")) {
dad25e4a
AR
385 ignore_add_errors = git_config_bool(var, value);
386 return 0;
387 }
9bd81e42 388 return git_default_config(var, value, cb);
dad25e4a
AR
389}
390
c972ec04
JH
391static int add_files(struct dir_struct *dir, int flags)
392{
393 int i, exit_status = 0;
394
395 if (dir->ignored_nr) {
439fb829 396 fprintf(stderr, _(ignore_error));
c972ec04
JH
397 for (i = 0; i < dir->ignored_nr; i++)
398 fprintf(stderr, "%s\n", dir->ignored[i]->name);
439fb829
ÆAB
399 fprintf(stderr, _("Use -f if you really want to add them.\n"));
400 die(_("no files added"));
c972ec04
JH
401 }
402
403 for (i = 0; i < dir->nr; i++)
404 if (add_file_to_cache(dir->entries[i]->name, flags)) {
405 if (!ignore_add_errors)
990ac4be 406 die(_("adding files failed"));
c972ec04
JH
407 exit_status = 1;
408 }
409 return exit_status;
410}
411
a633fca0 412int cmd_add(int argc, const char **argv, const char *prefix)
0d781539 413{
7ae02a30 414 int exit_status = 0;
c972ec04 415 int newfd;
5a76aff1 416 struct pathspec pathspec;
0d781539 417 struct dir_struct dir;
205ffa94 418 int flags;
c972ec04
JH
419 int add_new_files;
420 int require_pathspec;
81f45e7d 421 char *seen = NULL;
71c7b053 422 int implicit_dot = 0;
d226b14d 423 struct update_callback_data update_data;
5cde71d6 424
ed342fde
SB
425 git_config(add_config, NULL);
426
37782920 427 argc = parse_options(argc, argv, prefix, builtin_add_options,
c59cb03a 428 builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
b63e9950
WC
429 if (patch_interactive)
430 add_interactive = 1;
7c0ab445 431 if (add_interactive)
b4bd4668 432 exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
0d781539 433
c59cb03a
JS
434 if (edit_interactive)
435 return(edit_patch(argc, argv, prefix));
436 argc--;
437 argv++;
438
45c45e30
JH
439 if (0 <= addremove_explicit)
440 addremove = addremove_explicit;
441 else if (take_worktree_changes && ADDREMOVE_DEFAULT)
442 addremove = 0; /* "-u" was given but not "-A" */
443
3ba1f114 444 if (addremove && take_worktree_changes)
990ac4be 445 die(_("-A and -u are mutually incompatible"));
45c45e30
JH
446
447 /*
448 * Warn when "git add pathspec..." was given without "-u" or "-A"
d226b14d 449 * and pathspec... covers a removed path.
45c45e30 450 */
d226b14d
JH
451 memset(&update_data, 0, sizeof(update_data));
452 if (!take_worktree_changes && addremove_explicit < 0)
453 update_data.warn_add_would_remove = 1;
45c45e30
JH
454
455 if (!take_worktree_changes && addremove_explicit < 0 && argc)
456 /*
457 * Turn "git add pathspec..." to "git add -A pathspec..."
458 * in Git 2.0 but not yet
459 */
460 ; /* addremove = 1; */
461
108da0db 462 if (!show_only && ignore_missing)
990ac4be 463 die(_("Option --ignore-missing can only be used together with --dry-run"));
0fa2eb53
MM
464 if (addremove) {
465 option_with_implicit_dot = "--all";
466 short_option_with_implicit_dot = "-A";
467 }
468 if (take_worktree_changes) {
469 option_with_implicit_dot = "--update";
470 short_option_with_implicit_dot = "-u";
471 }
472 if (option_with_implicit_dot && !argc) {
3ba1f114
JH
473 static const char *here[2] = { ".", NULL };
474 argc = 1;
475 argv = here;
71c7b053 476 implicit_dot = 1;
3ba1f114
JH
477 }
478
c972ec04
JH
479 add_new_files = !take_worktree_changes && !refresh_only;
480 require_pathspec = !take_worktree_changes;
481
30ca07a2 482 newfd = hold_locked_index(&lock_file, 1);
0d781539 483
205ffa94 484 flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
01665924 485 (show_only ? ADD_CACHE_PRETEND : 0) |
39425819 486 (intent_to_add ? ADD_CACHE_INTENT : 0) |
1e5f764c
JH
487 (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
488 (!(addremove || take_worktree_changes)
71c7b053
JN
489 ? ADD_CACHE_IGNORE_REMOVAL : 0)) |
490 (implicit_dot ? ADD_CACHE_IMPLICIT_DOT : 0);
205ffa94 491
c972ec04 492 if (require_pathspec && argc == 0) {
990ac4be
ÆAB
493 fprintf(stderr, _("Nothing specified, nothing added.\n"));
494 fprintf(stderr, _("Maybe you wanted to say 'git add .'?\n"));
93b0d86a
JH
495 return 0;
496 }
0d781539 497
366bfcb6 498 if (read_cache() < 0)
990ac4be 499 die(_("index file corrupt"));
5a76aff1
NTND
500
501 /*
502 * Check the "pathspec '%s' did not match any files" block
503 * below before enabling new magic.
504 */
505 parse_pathspec(&pathspec, 0,
506 PATHSPEC_PREFER_FULL |
507 PATHSPEC_SYMLINK_LEADING_PATH |
508 PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE,
509 prefix, argv);
366bfcb6 510
1d8842d9
LT
511 if (add_new_files) {
512 int baselen;
7327d3d1 513 struct pathspec empty_pathspec;
1d8842d9
LT
514
515 /* Set up the default git porcelain excludes */
516 memset(&dir, 0, sizeof(dir));
517 if (!ignored_too) {
518 dir.flags |= DIR_COLLECT_IGNORED;
519 setup_standard_excludes(&dir);
520 }
521
7327d3d1 522 memset(&empty_pathspec, 0, sizeof(empty_pathspec));
1e5f764c 523 /* This picks up the paths that are not tracked */
7327d3d1 524 baselen = fill_directory(&dir, implicit_dot ? &empty_pathspec : &pathspec);
5a76aff1
NTND
525 if (pathspec.nr)
526 seen = prune_directory(&dir, pathspec.raw, baselen,
9df84e94 527 implicit_dot ? WARN_IMPLICIT_DOT : 0);
1d8842d9 528 }
1e5f764c 529
c972ec04 530 if (refresh_only) {
9b2d6149 531 refresh(verbose, &pathspec);
c972ec04 532 goto finish;
6a1ad325 533 }
0df7b8e5
JH
534 if (implicit_dot && prefix)
535 refresh_cache(REFRESH_QUIET);
6a1ad325 536
5a76aff1 537 if (pathspec.nr) {
81f45e7d 538 int i;
eb69934b 539
81f45e7d 540 if (!seen)
5a76aff1
NTND
541 seen = find_pathspecs_matching_against_index(pathspec.raw);
542
543 /*
544 * file_exists() assumes exact match
545 */
546 GUARD_PATHSPEC(&pathspec, PATHSPEC_FROMTOP);
547
548 for (i = 0; pathspec.raw[i]; i++) {
549 if (!seen[i] && pathspec.raw[i][0]
550 && !file_exists(pathspec.raw[i])) {
108da0db 551 if (ignore_missing) {
0188f6b3 552 int dtype = DT_UNKNOWN;
5a76aff1
NTND
553 if (is_excluded(&dir, pathspec.raw[i], &dtype))
554 dir_add_ignored(&dir, pathspec.raw[i], strlen(pathspec.raw[i]));
108da0db 555 } else
48168851 556 die(_("pathspec '%s' did not match any files"),
5a76aff1 557 pathspec.raw[i]);
108da0db 558 }
81f45e7d
JH
559 }
560 free(seen);
561 }
562
568508e7
JH
563 plug_bulk_checkin();
564
561954bf
JH
565 if ((flags & ADD_CACHE_IMPLICIT_DOT) && prefix) {
566 /*
567 * Check for modified files throughout the worktree so
568 * update_callback has a chance to warn about changes
569 * outside the cwd.
570 */
571 update_data.implicit_dot = prefix;
572 update_data.implicit_dot_len = strlen(prefix);
5a76aff1
NTND
573 free_pathspec(&pathspec);
574 memset(&pathspec, 0, sizeof(pathspec));
561954bf
JH
575 }
576 update_data.flags = flags & ~ADD_CACHE_IMPLICIT_DOT;
3efe8e43 577 update_files_in_cache(prefix, &pathspec, &update_data);
c972ec04 578
d226b14d 579 exit_status |= !!update_data.add_errors;
c972ec04
JH
580 if (add_new_files)
581 exit_status |= add_files(&dir, flags);
0d781539 582
568508e7
JH
583 unplug_bulk_checkin();
584
dfdac5d9 585 finish:
0d781539
LT
586 if (active_cache_changed) {
587 if (write_cache(newfd, active_cache, active_nr) ||
4ed7cd3a 588 commit_locked_index(&lock_file))
990ac4be 589 die(_("Unable to write new index file"));
0d781539
LT
590 }
591
7ae02a30 592 return exit_status;
0d781539 593}