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