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