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 = xopen(file, O_CREAT | O_WRONLY | O_TRUNC, 0666);
 317         rev.diffopt.file = xfdopen(out, "w");
 318         rev.diffopt.close_file = 1;
 319         if (run_diff_files(&rev, 0))
 320                 die(_("Could not write patch"));
 321
 322         if (launch_editor(file, NULL, NULL))
 323                 die(_("editing patch failed"));
 324
 325         if (stat(file, &st))
 326                 die_errno(_("Could not stat '%s'"), file);
 327         if (!st.st_size)
 328                 die(_("Empty patch. Aborted."));
 329
 330         child.git_cmd = 1;
 331         child.argv = apply_argv;
 332         if (run_command(&child))
 333                 die(_("Could not apply '%s'"), file);
 334
 335         unlink(file);
 336         free(file);
 337         return 0;
 338 }
 339
 340 static const char ignore_error[] =
 341 N_("The following paths are ignored by one of your .gitignore files:\n");
 342
 343 static int verbose, show_only, ignored_too, refresh_only;
 344 static int ignore_add_errors, intent_to_add, ignore_missing;
 345 static int warn_on_embedded_repo = 1;
 346
 347 #define ADDREMOVE_DEFAULT 1
 348 static int addremove = ADDREMOVE_DEFAULT;
 349 static int addremove_explicit = -1; /* unspecified */
 350
 351 static char *chmod_arg;
 352
 353 static 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
 360 static struct option builtin_add_options[] = {
 361         OPT__DRY_RUN(&show_only, N_("dry run")),
 362         OPT__VERBOSE(&verbose, N_("be verbose")),
 363         OPT_GROUP(""),
 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")),
 367         OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files"), 0),
 368         OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")),
 369         OPT_BOOL(0, "renormalize", &add_renormalize, N_("renormalize EOL of tracked files (implies -u)")),
 370         OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
 371         OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
 372         OPT_CALLBACK_F(0, "ignore-removal", &addremove_explicit,
 373           NULL /* takes no arguments */,
 374           N_("ignore paths removed in the working tree (same as --no-all)"),
 375           PARSE_OPT_NOARG, ignore_removal_cb),
 376         OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
 377         OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
 378         OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),
 379         OPT_STRING(0, "chmod", &chmod_arg, "(+|-)x",
 380                    N_("override the executable bit of the listed files")),
 381         OPT_HIDDEN_BOOL(0, "warn-embedded-repo", &warn_on_embedded_repo,
 382                         N_("warn when adding an embedded repository")),
 383         OPT_HIDDEN_BOOL(0, "legacy-stash-p", &legacy_stash_p,
 384                         N_("backend for `git stash -p`")),
 385         OPT_PATHSPEC_FROM_FILE(&pathspec_from_file),
 386         OPT_PATHSPEC_FILE_NUL(&pathspec_file_nul),
 387         OPT_END(),
 388 };
 389
 390 static int add_config(const char *var, const char *value, void *cb)
 391 {
 392         if (!strcmp(var, "add.ignoreerrors") ||
 393             !strcmp(var, "add.ignore-errors")) {
 394                 ignore_add_errors = git_config_bool(var, value);
 395                 return 0;
 396         }
 397
 398         return git_default_config(var, value, cb);
 399 }
 400
 401 static const char embedded_advice[] = N_(
 402 "You've added another git repository inside your current repository.\n"
 403 "Clones of the outer repository will not contain the contents of\n"
 404 "the embedded repository and will not know how to obtain it.\n"
 405 "If you meant to add a submodule, use:\n"
 406 "\n"
 407 "       git submodule add <url> %s\n"
 408 "\n"
 409 "If you added this path by mistake, you can remove it from the\n"
 410 "index with:\n"
 411 "\n"
 412 "       git rm --cached %s\n"
 413 "\n"
 414 "See \"git help submodule\" for more information."
 415 );
 416
 417 static void check_embedded_repo(const char *path)
 418 {
 419         struct strbuf name = STRBUF_INIT;
 420
 421         if (!warn_on_embedded_repo)
 422                 return;
 423         if (!ends_with(path, "/"))
 424                 return;
 425
 426         /* Drop trailing slash for aesthetics */
 427         strbuf_addstr(&name, path);
 428         strbuf_strip_suffix(&name, "/");
 429
 430         warning(_("adding embedded git repository: %s"), name.buf);
 431         if (advice_add_embedded_repo) {
 432                 advise(embedded_advice, name.buf, name.buf);
 433                 /* there may be multiple entries; advise only once */
 434                 advice_add_embedded_repo = 0;
 435         }
 436
 437         strbuf_release(&name);
 438 }
 439
 440 static int add_files(struct dir_struct *dir, int flags)
 441 {
 442         int i, exit_status = 0;
 443
 444         if (dir->ignored_nr) {
 445                 fprintf(stderr, _(ignore_error));
 446                 for (i = 0; i < dir->ignored_nr; i++)
 447                         fprintf(stderr, "%s\n", dir->ignored[i]->name);
 448                 if (advice_add_ignored_file)
 449                         advise(_("Use -f if you really want to add them.\n"
 450                                 "Turn this message off by running\n"
 451                                 "\"git config advice.addIgnoredFile false\""));
 452                 exit_status = 1;
 453         }
 454
 455         for (i = 0; i < dir->nr; i++) {
 456                 if (add_file_to_index(&the_index, dir->entries[i]->name, flags)) {
 457                         if (!ignore_add_errors)
 458                                 die(_("adding files failed"));
 459                         exit_status = 1;
 460                 } else {
 461                         check_embedded_repo(dir->entries[i]->name);
 462                 }
 463         }
 464         return exit_status;
 465 }
 466
 467 int cmd_add(int argc, const char **argv, const char *prefix)
 468 {
 469         int exit_status = 0;
 470         struct pathspec pathspec;
 471         struct dir_struct dir = DIR_INIT;
 472         int flags;
 473         int add_new_files;
 474         int require_pathspec;
 475         char *seen = NULL;
 476         struct lock_file lock_file = LOCK_INIT;
 477
 478         git_config(add_config, NULL);
 479
 480         argc = parse_options(argc, argv, prefix, builtin_add_options,
 481                           builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
 482         if (patch_interactive)
 483                 add_interactive = 1;
 484         if (add_interactive) {
 485                 if (show_only)
 486                         die(_("--dry-run is incompatible with --interactive/--patch"));
 487                 if (pathspec_from_file)
 488                         die(_("--pathspec-from-file is incompatible with --interactive/--patch"));
 489                 exit(interactive_add(argv + 1, prefix, patch_interactive));
 490         }
 491         if (legacy_stash_p) {
 492                 struct pathspec pathspec;
 493
 494                 parse_pathspec(&pathspec, 0,
 495                         PATHSPEC_PREFER_FULL |
 496                         PATHSPEC_SYMLINK_LEADING_PATH |
 497                         PATHSPEC_PREFIX_ORIGIN,
 498                         prefix, argv);
 499
 500                 return run_add_interactive(NULL, "--patch=stash", &pathspec);
 501         }
 502
 503         if (edit_interactive) {
 504                 if (pathspec_from_file)
 505                         die(_("--pathspec-from-file is incompatible with --edit"));
 506                 return(edit_patch(argc, argv, prefix));
 507         }
 508         argc--;
 509         argv++;
 510
 511         if (0 <= addremove_explicit)
 512                 addremove = addremove_explicit;
 513         else if (take_worktree_changes && ADDREMOVE_DEFAULT)
 514                 addremove = 0; /* "-u" was given but not "-A" */
 515
 516         if (addremove && take_worktree_changes)
 517                 die(_("-A and -u are mutually incompatible"));
 518
 519         if (!show_only && ignore_missing)
 520                 die(_("Option --ignore-missing can only be used together with --dry-run"));
 521
 522         if (chmod_arg && ((chmod_arg[0] != '-' && chmod_arg[0] != '+') ||
 523                           chmod_arg[1] != 'x' || chmod_arg[2]))
 524                 die(_("--chmod param '%s' must be either -x or +x"), chmod_arg);
 525
 526         add_new_files = !take_worktree_changes && !refresh_only && !add_renormalize;
 527         require_pathspec = !(take_worktree_changes || (0 < addremove_explicit));
 528
 529         hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
 530
 531         /*
 532          * Check the "pathspec '%s' did not match any files" block
 533          * below before enabling new magic.
 534          */
 535         parse_pathspec(&pathspec, PATHSPEC_ATTR,
 536                        PATHSPEC_PREFER_FULL |
 537                        PATHSPEC_SYMLINK_LEADING_PATH,
 538                        prefix, argv);
 539
 540         if (pathspec_from_file) {
 541                 if (pathspec.nr)
 542                         die(_("--pathspec-from-file is incompatible with pathspec arguments"));
 543
 544                 parse_pathspec_file(&pathspec, PATHSPEC_ATTR,
 545                                     PATHSPEC_PREFER_FULL |
 546                                     PATHSPEC_SYMLINK_LEADING_PATH,
 547                                     prefix, pathspec_from_file, pathspec_file_nul);
 548         } else if (pathspec_file_nul) {
 549                 die(_("--pathspec-file-nul requires --pathspec-from-file"));
 550         }
 551
 552         if (require_pathspec && pathspec.nr == 0) {
 553                 fprintf(stderr, _("Nothing specified, nothing added.\n"));
 554                 if (advice_add_empty_pathspec)
 555                         advise( _("Maybe you wanted to say 'git add .'?\n"
 556                                 "Turn this message off by running\n"
 557                                 "\"git config advice.addEmptyPathspec false\""));
 558                 return 0;
 559         }
 560
 561         if (!take_worktree_changes && addremove_explicit < 0 && pathspec.nr)
 562                 /* Turn "git add pathspec..." to "git add -A pathspec..." */
 563                 addremove = 1;
 564
 565         flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
 566                  (show_only ? ADD_CACHE_PRETEND : 0) |
 567                  (intent_to_add ? ADD_CACHE_INTENT : 0) |
 568                  (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
 569                  (!(addremove || take_worktree_changes)
 570                   ? ADD_CACHE_IGNORE_REMOVAL : 0));
 571
 572         if (read_cache_preload(&pathspec) < 0)
 573                 die(_("index file corrupt"));
 574
 575         die_in_unpopulated_submodule(&the_index, prefix);
 576         die_path_inside_submodule(&the_index, &pathspec);
 577
 578         if (add_new_files) {
 579                 int baselen;
 580
 581                 /* Set up the default git porcelain excludes */
 582                 if (!ignored_too) {
 583                         dir.flags |= DIR_COLLECT_IGNORED;
 584                         setup_standard_excludes(&dir);
 585                 }
 586
 587                 /* This picks up the paths that are not tracked */
 588                 baselen = fill_directory(&dir, &the_index, &pathspec);
 589                 if (pathspec.nr)
 590                         seen = prune_directory(&dir, &pathspec, baselen);
 591         }
 592
 593         if (refresh_only) {
 594                 exit_status |= refresh(verbose, &pathspec);
 595                 goto finish;
 596         }
 597
 598         if (pathspec.nr) {
 599                 int i;
 600                 char *skip_worktree_seen = NULL;
 601                 struct string_list only_match_skip_worktree = STRING_LIST_INIT_NODUP;
 602
 603                 if (!seen)
 604                         seen = find_pathspecs_matching_against_index(&pathspec,
 605                                         &the_index, PS_IGNORE_SKIP_WORKTREE);
 606
 607                 /*
 608                  * file_exists() assumes exact match
 609                  */
 610                 GUARD_PATHSPEC(&pathspec,
 611                                PATHSPEC_FROMTOP |
 612                                PATHSPEC_LITERAL |
 613                                PATHSPEC_GLOB |
 614                                PATHSPEC_ICASE |
 615                                PATHSPEC_EXCLUDE);
 616
 617                 for (i = 0; i < pathspec.nr; i++) {
 618                         const char *path = pathspec.items[i].match;
 619
 620                         if (pathspec.items[i].magic & PATHSPEC_EXCLUDE)
 621                                 continue;
 622                         if (seen[i])
 623                                 continue;
 624
 625                         if (matches_skip_worktree(&pathspec, i, &skip_worktree_seen)) {
 626                                 string_list_append(&only_match_skip_worktree,
 627                                                    pathspec.items[i].original);
 628                                 continue;
 629                         }
 630
 631                         /* Don't complain at 'git add .' on empty repo */
 632                         if (!path[0])
 633                                 continue;
 634
 635                         if ((pathspec.items[i].magic & (PATHSPEC_GLOB | PATHSPEC_ICASE)) ||
 636                             !file_exists(path)) {
 637                                 if (ignore_missing) {
 638                                         int dtype = DT_UNKNOWN;
 639                                         if (is_excluded(&dir, &the_index, path, &dtype))
 640                                                 dir_add_ignored(&dir, &the_index,
 641                                                                 path, pathspec.items[i].len);
 642                                 } else
 643                                         die(_("pathspec '%s' did not match any files"),
 644                                             pathspec.items[i].original);
 645                         }
 646                 }
 647
 648
 649                 if (only_match_skip_worktree.nr) {
 650                         advise_on_updating_sparse_paths(&only_match_skip_worktree);
 651                         exit_status = 1;
 652                 }
 653
 654                 free(seen);
 655                 free(skip_worktree_seen);
 656                 string_list_clear(&only_match_skip_worktree, 0);
 657         }
 658
 659         plug_bulk_checkin();
 660
 661         if (add_renormalize)
 662                 exit_status |= renormalize_tracked_files(&pathspec, flags);
 663         else
 664                 exit_status |= add_files_to_cache(prefix, &pathspec, flags);
 665
 666         if (add_new_files)
 667                 exit_status |= add_files(&dir, flags);
 668
 669         if (chmod_arg && pathspec.nr)
 670                 exit_status |= chmod_pathspec(&pathspec, chmod_arg[0], show_only);
 671         unplug_bulk_checkin();
 672
 673 finish:
 674         if (write_locked_index(&the_index, &lock_file,
 675                                COMMIT_LOCK | SKIP_IF_UNCHANGED))
 676                 die(_("Unable to write new index file"));
 677
 678         dir_clear(&dir);
 679         UNLEAK(pathspec);
 680         return exit_status;
 681 }