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