builtin/add.c

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