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
 145         /*
 146          * Use an ODB transaction to optimize adding multiple objects.
 147          * This function is invoked from commands other than 'add', which
 148          * may not have their own transaction active.
 149          */
 150         begin_odb_transaction();
 151         run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);
 152         end_odb_transaction();
 153
 154         release_revisions(&rev);
 155         return !!data.add_errors;
 156 }
 157
 158 static int renormalize_tracked_files(const struct pathspec *pathspec, int flags)
 159 {
 160         int i, retval = 0;
 161
 162         for (i = 0; i < active_nr; i++) {
 163                 struct cache_entry *ce = active_cache[i];
 164
 165                 if (!include_sparse &&
 166                     (ce_skip_worktree(ce) ||
 167                      !path_in_sparse_checkout(ce->name, &the_index)))
 168                         continue;
 169                 if (ce_stage(ce))
 170                         continue; /* do not touch unmerged paths */
 171                 if (!S_ISREG(ce->ce_mode) && !S_ISLNK(ce->ce_mode))
 172                         continue; /* do not touch non blobs */
 173                 if (pathspec && !ce_path_match(&the_index, ce, pathspec, NULL))
 174                         continue;
 175                 retval |= add_file_to_cache(ce->name, flags | ADD_CACHE_RENORMALIZE);
 176         }
 177
 178         return retval;
 179 }
 180
 181 static char *prune_directory(struct dir_struct *dir, struct pathspec *pathspec, int prefix)
 182 {
 183         char *seen;
 184         int i;
 185         struct dir_entry **src, **dst;
 186
 187         seen = xcalloc(pathspec->nr, 1);
 188
 189         src = dst = dir->entries;
 190         i = dir->nr;
 191         while (--i >= 0) {
 192                 struct dir_entry *entry = *src++;
 193                 if (dir_path_match(&the_index, entry, pathspec, prefix, seen))
 194                         *dst++ = entry;
 195         }
 196         dir->nr = dst - dir->entries;
 197         add_pathspec_matches_against_index(pathspec, &the_index, seen,
 198                                            PS_IGNORE_SKIP_WORKTREE);
 199         return seen;
 200 }
 201
 202 static int refresh(int verbose, const struct pathspec *pathspec)
 203 {
 204         char *seen;
 205         int i, ret = 0;
 206         char *skip_worktree_seen = NULL;
 207         struct string_list only_match_skip_worktree = STRING_LIST_INIT_NODUP;
 208         int flags = REFRESH_IGNORE_SKIP_WORKTREE |
 209                     (verbose ? REFRESH_IN_PORCELAIN : REFRESH_QUIET);
 210
 211         seen = xcalloc(pathspec->nr, 1);
 212         refresh_index(&the_index, flags, pathspec, seen,
 213                       _("Unstaged changes after refreshing the index:"));
 214         for (i = 0; i < pathspec->nr; i++) {
 215                 if (!seen[i]) {
 216                         const char *path = pathspec->items[i].original;
 217
 218                         if (matches_skip_worktree(pathspec, i, &skip_worktree_seen) ||
 219                             !path_in_sparse_checkout(path, &the_index)) {
 220                                 string_list_append(&only_match_skip_worktree,
 221                                                    pathspec->items[i].original);
 222                         } else {
 223                                 die(_("pathspec '%s' did not match any files"),
 224                                     pathspec->items[i].original);
 225                         }
 226                 }
 227         }
 228
 229         if (only_match_skip_worktree.nr) {
 230                 advise_on_updating_sparse_paths(&only_match_skip_worktree);
 231                 ret = 1;
 232         }
 233
 234         free(seen);
 235         free(skip_worktree_seen);
 236         string_list_clear(&only_match_skip_worktree, 0);
 237         return ret;
 238 }
 239
 240 int run_add_interactive(const char *revision, const char *patch_mode,
 241                         const struct pathspec *pathspec)
 242 {
 243         int i;
 244         struct child_process cmd = CHILD_PROCESS_INIT;
 245         int use_builtin_add_i =
 246                 git_env_bool("GIT_TEST_ADD_I_USE_BUILTIN", -1);
 247
 248         if (use_builtin_add_i < 0 &&
 249             git_config_get_bool("add.interactive.usebuiltin",
 250                                 &use_builtin_add_i))
 251                 use_builtin_add_i = 1;
 252
 253         if (use_builtin_add_i != 0) {
 254                 enum add_p_mode mode;
 255
 256                 if (!patch_mode)
 257                         return !!run_add_i(the_repository, pathspec);
 258
 259                 if (!strcmp(patch_mode, "--patch"))
 260                         mode = ADD_P_ADD;
 261                 else if (!strcmp(patch_mode, "--patch=stash"))
 262                         mode = ADD_P_STASH;
 263                 else if (!strcmp(patch_mode, "--patch=reset"))
 264                         mode = ADD_P_RESET;
 265                 else if (!strcmp(patch_mode, "--patch=checkout"))
 266                         mode = ADD_P_CHECKOUT;
 267                 else if (!strcmp(patch_mode, "--patch=worktree"))
 268                         mode = ADD_P_WORKTREE;
 269                 else
 270                         die("'%s' not supported", patch_mode);
 271
 272                 return !!run_add_p(the_repository, mode, revision, pathspec);
 273         }
 274
 275         strvec_push(&cmd.args, "add--interactive");
 276         if (patch_mode)
 277                 strvec_push(&cmd.args, patch_mode);
 278         if (revision)
 279                 strvec_push(&cmd.args, revision);
 280         strvec_push(&cmd.args, "--");
 281         for (i = 0; i < pathspec->nr; i++)
 282                 /* pass original pathspec, to be re-parsed */
 283                 strvec_push(&cmd.args, pathspec->items[i].original);
 284
 285         cmd.git_cmd = 1;
 286         return run_command(&cmd);
 287 }
 288
 289 int interactive_add(const char **argv, const char *prefix, int patch)
 290 {
 291         struct pathspec pathspec;
 292
 293         parse_pathspec(&pathspec, 0,
 294                        PATHSPEC_PREFER_FULL |
 295                        PATHSPEC_SYMLINK_LEADING_PATH |
 296                        PATHSPEC_PREFIX_ORIGIN,
 297                        prefix, argv);
 298
 299         return run_add_interactive(NULL,
 300                                    patch ? "--patch" : NULL,
 301                                    &pathspec);
 302 }
 303
 304 static int edit_patch(int argc, const char **argv, const char *prefix)
 305 {
 306         char *file = git_pathdup("ADD_EDIT.patch");
 307         struct child_process child = CHILD_PROCESS_INIT;
 308         struct rev_info rev;
 309         int out;
 310         struct stat st;
 311
 312         git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
 313
 314         if (read_cache() < 0)
 315                 die(_("Could not read the index"));
 316
 317         repo_init_revisions(the_repository, &rev, prefix);
 318         rev.diffopt.context = 7;
 319
 320         argc = setup_revisions(argc, argv, &rev, NULL);
 321         rev.diffopt.output_format = DIFF_FORMAT_PATCH;
 322         rev.diffopt.use_color = 0;
 323         rev.diffopt.flags.ignore_dirty_submodules = 1;
 324         out = xopen(file, O_CREAT | O_WRONLY | O_TRUNC, 0666);
 325         rev.diffopt.file = xfdopen(out, "w");
 326         rev.diffopt.close_file = 1;
 327         if (run_diff_files(&rev, 0))
 328                 die(_("Could not write patch"));
 329
 330         if (launch_editor(file, NULL, NULL))
 331                 die(_("editing patch failed"));
 332
 333         if (stat(file, &st))
 334                 die_errno(_("Could not stat '%s'"), file);
 335         if (!st.st_size)
 336                 die(_("Empty patch. Aborted."));
 337
 338         child.git_cmd = 1;
 339         strvec_pushl(&child.args, "apply", "--recount", "--cached", file,
 340                      NULL);
 341         if (run_command(&child))
 342                 die(_("Could not apply '%s'"), file);
 343
 344         unlink(file);
 345         free(file);
 346         release_revisions(&rev);
 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_PATHSPEC_FROM_FILE(&pathspec_from_file),
 395         OPT_PATHSPEC_FILE_NUL(&pathspec_file_nul),
 396         OPT_END(),
 397 };
 398
 399 static int add_config(const char *var, const char *value, void *cb)
 400 {
 401         if (!strcmp(var, "add.ignoreerrors") ||
 402             !strcmp(var, "add.ignore-errors")) {
 403                 ignore_add_errors = git_config_bool(var, value);
 404                 return 0;
 405         }
 406
 407         return git_default_config(var, value, cb);
 408 }
 409
 410 static const char embedded_advice[] = N_(
 411 "You've added another git repository inside your current repository.\n"
 412 "Clones of the outer repository will not contain the contents of\n"
 413 "the embedded repository and will not know how to obtain it.\n"
 414 "If you meant to add a submodule, use:\n"
 415 "\n"
 416 "       git submodule add <url> %s\n"
 417 "\n"
 418 "If you added this path by mistake, you can remove it from the\n"
 419 "index with:\n"
 420 "\n"
 421 "       git rm --cached %s\n"
 422 "\n"
 423 "See \"git help submodule\" for more information."
 424 );
 425
 426 static void check_embedded_repo(const char *path)
 427 {
 428         struct strbuf name = STRBUF_INIT;
 429         static int adviced_on_embedded_repo = 0;
 430
 431         if (!warn_on_embedded_repo)
 432                 return;
 433         if (!ends_with(path, "/"))
 434                 return;
 435
 436         /* Drop trailing slash for aesthetics */
 437         strbuf_addstr(&name, path);
 438         strbuf_strip_suffix(&name, "/");
 439
 440         warning(_("adding embedded git repository: %s"), name.buf);
 441         if (!adviced_on_embedded_repo &&
 442             advice_enabled(ADVICE_ADD_EMBEDDED_REPO)) {
 443                 advise(embedded_advice, name.buf, name.buf);
 444                 adviced_on_embedded_repo = 1;
 445         }
 446
 447         strbuf_release(&name);
 448 }
 449
 450 static int add_files(struct dir_struct *dir, int flags)
 451 {
 452         int i, exit_status = 0;
 453         struct string_list matched_sparse_paths = STRING_LIST_INIT_NODUP;
 454
 455         if (dir->ignored_nr) {
 456                 fprintf(stderr, _(ignore_error));
 457                 for (i = 0; i < dir->ignored_nr; i++)
 458                         fprintf(stderr, "%s\n", dir->ignored[i]->name);
 459                 if (advice_enabled(ADVICE_ADD_IGNORED_FILE))
 460                         advise(_("Use -f if you really want to add them.\n"
 461                                 "Turn this message off by running\n"
 462                                 "\"git config advice.addIgnoredFile false\""));
 463                 exit_status = 1;
 464         }
 465
 466         for (i = 0; i < dir->nr; i++) {
 467                 if (!include_sparse &&
 468                     !path_in_sparse_checkout(dir->entries[i]->name, &the_index)) {
 469                         string_list_append(&matched_sparse_paths,
 470                                            dir->entries[i]->name);
 471                         continue;
 472                 }
 473                 if (add_file_to_index(&the_index, dir->entries[i]->name, flags)) {
 474                         if (!ignore_add_errors)
 475                                 die(_("adding files failed"));
 476                         exit_status = 1;
 477                 } else {
 478                         check_embedded_repo(dir->entries[i]->name);
 479                 }
 480         }
 481
 482         if (matched_sparse_paths.nr) {
 483                 advise_on_updating_sparse_paths(&matched_sparse_paths);
 484                 exit_status = 1;
 485         }
 486
 487         string_list_clear(&matched_sparse_paths, 0);
 488
 489         return exit_status;
 490 }
 491
 492 int cmd_add(int argc, const char **argv, const char *prefix)
 493 {
 494         int exit_status = 0;
 495         struct pathspec pathspec;
 496         struct dir_struct dir = DIR_INIT;
 497         int flags;
 498         int add_new_files;
 499         int require_pathspec;
 500         char *seen = NULL;
 501         struct lock_file lock_file = LOCK_INIT;
 502
 503         git_config(add_config, NULL);
 504
 505         argc = parse_options(argc, argv, prefix, builtin_add_options,
 506                           builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
 507         if (patch_interactive)
 508                 add_interactive = 1;
 509         if (add_interactive) {
 510                 if (show_only)
 511                         die(_("options '%s' and '%s' cannot be used together"), "--dry-run", "--interactive/--patch");
 512                 if (pathspec_from_file)
 513                         die(_("options '%s' and '%s' cannot be used together"), "--pathspec-from-file", "--interactive/--patch");
 514                 exit(interactive_add(argv + 1, prefix, patch_interactive));
 515         }
 516
 517         if (edit_interactive) {
 518                 if (pathspec_from_file)
 519                         die(_("options '%s' and '%s' cannot be used together"), "--pathspec-from-file", "--edit");
 520                 return(edit_patch(argc, argv, prefix));
 521         }
 522         argc--;
 523         argv++;
 524
 525         if (0 <= addremove_explicit)
 526                 addremove = addremove_explicit;
 527         else if (take_worktree_changes && ADDREMOVE_DEFAULT)
 528                 addremove = 0; /* "-u" was given but not "-A" */
 529
 530         if (addremove && take_worktree_changes)
 531                 die(_("options '%s' and '%s' cannot be used together"), "-A", "-u");
 532
 533         if (!show_only && ignore_missing)
 534                 die(_("the option '%s' requires '%s'"), "--ignore-missing", "--dry-run");
 535
 536         if (chmod_arg && ((chmod_arg[0] != '-' && chmod_arg[0] != '+') ||
 537                           chmod_arg[1] != 'x' || chmod_arg[2]))
 538                 die(_("--chmod param '%s' must be either -x or +x"), chmod_arg);
 539
 540         add_new_files = !take_worktree_changes && !refresh_only && !add_renormalize;
 541         require_pathspec = !(take_worktree_changes || (0 < addremove_explicit));
 542
 543         prepare_repo_settings(the_repository);
 544         the_repository->settings.command_requires_full_index = 0;
 545
 546         hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR);
 547
 548         /*
 549          * Check the "pathspec '%s' did not match any files" block
 550          * below before enabling new magic.
 551          */
 552         parse_pathspec(&pathspec, PATHSPEC_ATTR,
 553                        PATHSPEC_PREFER_FULL |
 554                        PATHSPEC_SYMLINK_LEADING_PATH,
 555                        prefix, argv);
 556
 557         if (pathspec_from_file) {
 558                 if (pathspec.nr)
 559                         die(_("'%s' and pathspec arguments cannot be used together"), "--pathspec-from-file");
 560
 561                 parse_pathspec_file(&pathspec, PATHSPEC_ATTR,
 562                                     PATHSPEC_PREFER_FULL |
 563                                     PATHSPEC_SYMLINK_LEADING_PATH,
 564                                     prefix, pathspec_from_file, pathspec_file_nul);
 565         } else if (pathspec_file_nul) {
 566                 die(_("the option '%s' requires '%s'"), "--pathspec-file-nul", "--pathspec-from-file");
 567         }
 568
 569         if (require_pathspec && pathspec.nr == 0) {
 570                 fprintf(stderr, _("Nothing specified, nothing added.\n"));
 571                 if (advice_enabled(ADVICE_ADD_EMPTY_PATHSPEC))
 572                         advise( _("Maybe you wanted to say 'git add .'?\n"
 573                                 "Turn this message off by running\n"
 574                                 "\"git config advice.addEmptyPathspec false\""));
 575                 return 0;
 576         }
 577
 578         if (!take_worktree_changes && addremove_explicit < 0 && pathspec.nr)
 579                 /* Turn "git add pathspec..." to "git add -A pathspec..." */
 580                 addremove = 1;
 581
 582         flags = ((verbose ? ADD_CACHE_VERBOSE : 0) |
 583                  (show_only ? ADD_CACHE_PRETEND : 0) |
 584                  (intent_to_add ? ADD_CACHE_INTENT : 0) |
 585                  (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS : 0) |
 586                  (!(addremove || take_worktree_changes)
 587                   ? ADD_CACHE_IGNORE_REMOVAL : 0));
 588
 589         if (read_cache_preload(&pathspec) < 0)
 590                 die(_("index file corrupt"));
 591
 592         die_in_unpopulated_submodule(&the_index, prefix);
 593         die_path_inside_submodule(&the_index, &pathspec);
 594
 595         if (add_new_files) {
 596                 int baselen;
 597
 598                 /* Set up the default git porcelain excludes */
 599                 if (!ignored_too) {
 600                         dir.flags |= DIR_COLLECT_IGNORED;
 601                         setup_standard_excludes(&dir);
 602                 }
 603
 604                 /* This picks up the paths that are not tracked */
 605                 baselen = fill_directory(&dir, &the_index, &pathspec);
 606                 if (pathspec.nr)
 607                         seen = prune_directory(&dir, &pathspec, baselen);
 608         }
 609
 610         if (refresh_only) {
 611                 exit_status |= refresh(verbose, &pathspec);
 612                 goto finish;
 613         }
 614
 615         if (pathspec.nr) {
 616                 int i;
 617                 char *skip_worktree_seen = NULL;
 618                 struct string_list only_match_skip_worktree = STRING_LIST_INIT_NODUP;
 619
 620                 if (!seen)
 621                         seen = find_pathspecs_matching_against_index(&pathspec,
 622                                         &the_index, PS_IGNORE_SKIP_WORKTREE);
 623
 624                 /*
 625                  * file_exists() assumes exact match
 626                  */
 627                 GUARD_PATHSPEC(&pathspec,
 628                                PATHSPEC_FROMTOP |
 629                                PATHSPEC_LITERAL |
 630                                PATHSPEC_GLOB |
 631                                PATHSPEC_ICASE |
 632                                PATHSPEC_EXCLUDE);
 633
 634                 for (i = 0; i < pathspec.nr; i++) {
 635                         const char *path = pathspec.items[i].match;
 636
 637                         if (pathspec.items[i].magic & PATHSPEC_EXCLUDE)
 638                                 continue;
 639                         if (seen[i])
 640                                 continue;
 641
 642                         if (!include_sparse &&
 643                             matches_skip_worktree(&pathspec, i, &skip_worktree_seen)) {
 644                                 string_list_append(&only_match_skip_worktree,
 645                                                    pathspec.items[i].original);
 646                                 continue;
 647                         }
 648
 649                         /* Don't complain at 'git add .' on empty repo */
 650                         if (!path[0])
 651                                 continue;
 652
 653                         if ((pathspec.items[i].magic & (PATHSPEC_GLOB | PATHSPEC_ICASE)) ||
 654                             !file_exists(path)) {
 655                                 if (ignore_missing) {
 656                                         int dtype = DT_UNKNOWN;
 657                                         if (is_excluded(&dir, &the_index, path, &dtype))
 658                                                 dir_add_ignored(&dir, &the_index,
 659                                                                 path, pathspec.items[i].len);
 660                                 } else
 661                                         die(_("pathspec '%s' did not match any files"),
 662                                             pathspec.items[i].original);
 663                         }
 664                 }
 665
 666
 667                 if (only_match_skip_worktree.nr) {
 668                         advise_on_updating_sparse_paths(&only_match_skip_worktree);
 669                         exit_status = 1;
 670                 }
 671
 672                 free(seen);
 673                 free(skip_worktree_seen);
 674                 string_list_clear(&only_match_skip_worktree, 0);
 675         }
 676
 677         begin_odb_transaction();
 678
 679         if (add_renormalize)
 680                 exit_status |= renormalize_tracked_files(&pathspec, flags);
 681         else
 682                 exit_status |= add_files_to_cache(prefix, &pathspec, flags);
 683
 684         if (add_new_files)
 685                 exit_status |= add_files(&dir, flags);
 686
 687         if (chmod_arg && pathspec.nr)
 688                 exit_status |= chmod_pathspec(&pathspec, chmod_arg[0], show_only);
 689         end_odb_transaction();
 690
 691 finish:
 692         if (write_locked_index(&the_index, &lock_file,
 693                                COMMIT_LOCK | SKIP_IF_UNCHANGED))
 694                 die(_("Unable to write new index file"));
 695
 696         dir_clear(&dir);
 697         UNLEAK(pathspec);
 698         return exit_status;
 699 }