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