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