builtin/add.c

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