Bug Summary

File:builtin/update-index.c
Location:line 1063, column 2
Description:Value stored to 'argc' is never read

Annotated Source Code

1/*
2 * GIT - The information manager from hell
3 *
4 * Copyright (C) Linus Torvalds, 2005
5 */
6#include "cache.h"
7#include "lockfile.h"
8#include "quote.h"
9#include "cache-tree.h"
10#include "tree-walk.h"
11#include "builtin.h"
12#include "refs.h"
13#include "resolve-undo.h"
14#include "parse-options.h"
15#include "pathspec.h"
16#include "dir.h"
17#include "split-index.h"
18
19/*
20 * Default to not allowing changes to the list of files. The
21 * tool doesn't actually care, but this makes it harder to add
22 * files to the revision control by mistake by doing something
23 * like "git update-index *" and suddenly having all the object
24 * files be revision controlled.
25 */
26static int allow_add;
27static int allow_remove;
28static int allow_replace;
29static int info_only;
30static int force_remove;
31static int verbose;
32static int mark_valid_only;
33static int mark_skip_worktree_only;
34#define MARK_FLAG1 1
35#define UNMARK_FLAG2 2
36static struct strbuf mtime_dir = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
37
38/* Untracked cache mode */
39enum uc_mode {
40 UC_UNSPECIFIED = -1,
41 UC_DISABLE = 0,
42 UC_ENABLE,
43 UC_TEST,
44 UC_FORCE
45};
46
47__attribute__((format (printf, 1, 2)))
48static void report(const char *fmt, ...)
49{
50 va_list vp;
51
52 if (!verbose)
53 return;
54
55 va_start(vp, fmt)__builtin_va_start(vp, fmt);
56 vprintf(fmt, vp);
57 putchar('\n');
58 va_end(vp)__builtin_va_end(vp);
59}
60
61static void remove_test_directory(void)
62{
63 if (mtime_dir.len)
64 remove_dir_recursively(&mtime_dir, 0);
65}
66
67static const char *get_mtime_path(const char *path)
68{
69 static struct strbuf sb = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
70 strbuf_reset(&sb)strbuf_setlen(&sb, 0);
71 strbuf_addf(&sb, "%s/%s", mtime_dir.buf, path);
72 return sb.buf;
73}
74
75static void xmkdir(const char *path)
76{
77 path = get_mtime_path(path);
78 if (mkdir(path, 0700))
79 die_errno(_("failed to create directory %s"), path);
80}
81
82static int xstat_mtime_dir(struct stat *st)
83{
84 if (stat(mtime_dir.buf, st))
85 die_errno(_("failed to stat %s"), mtime_dir.buf);
86 return 0;
87}
88
89static int create_file(const char *path)
90{
91 int fd;
92 path = get_mtime_path(path);
93 fd = open(path, O_CREAT0x0200 | O_RDWR0x0002, 0644);
94 if (fd < 0)
95 die_errno(_("failed to create file %s"), path);
96 return fd;
97}
98
99static void xunlink(const char *path)
100{
101 path = get_mtime_path(path);
102 if (unlink(path))
103 die_errno(_("failed to delete file %s"), path);
104}
105
106static void xrmdir(const char *path)
107{
108 path = get_mtime_path(path);
109 if (rmdir(path))
110 die_errno(_("failed to delete directory %s"), path);
111}
112
113static void avoid_racy(void)
114{
115 /*
116 * not use if we could usleep(10) if USE_NSEC is defined. The
117 * field nsec could be there, but the OS could choose to
118 * ignore it?
119 */
120 sleep(1);
121}
122
123static int test_if_untracked_cache_is_supported(void)
124{
125 struct stat st;
126 struct stat_data base;
127 int fd, ret = 0;
128
129 strbuf_addstr(&mtime_dir, "mtime-test-XXXXXX");
130 if (!mkdtemp(mtime_dir.buf))
131 die_errno("Could not make temporary directory");
132
133 fprintf(stderr__stderrp, _("Testing mtime in '%s' "), xgetcwd());
134 atexit(remove_test_directory);
135 xstat_mtime_dir(&st);
136 fill_stat_data(&base, &st);
137 fputc('.', stderr__stderrp);
138
139 avoid_racy();
140 fd = create_file("newfile");
141 xstat_mtime_dir(&st);
142 if (!match_stat_data(&base, &st)) {
143 close(fd);
144 fputc('\n', stderr__stderrp);
145 fprintf_ln(stderr__stderrp,_("directory stat info does not "
146 "change after adding a new file"));
147 goto done;
148 }
149 fill_stat_data(&base, &st);
150 fputc('.', stderr__stderrp);
151
152 avoid_racy();
153 xmkdir("new-dir");
154 xstat_mtime_dir(&st);
155 if (!match_stat_data(&base, &st)) {
156 close(fd);
157 fputc('\n', stderr__stderrp);
158 fprintf_ln(stderr__stderrp, _("directory stat info does not change "
159 "after adding a new directory"));
160 goto done;
161 }
162 fill_stat_data(&base, &st);
163 fputc('.', stderr__stderrp);
164
165 avoid_racy();
166 write_or_die(fd, "data", 4);
167 close(fd);
168 xstat_mtime_dir(&st);
169 if (match_stat_data(&base, &st)) {
170 fputc('\n', stderr__stderrp);
171 fprintf_ln(stderr__stderrp, _("directory stat info changes "
172 "after updating a file"));
173 goto done;
174 }
175 fputc('.', stderr__stderrp);
176
177 avoid_racy();
178 close(create_file("new-dir/new"));
179 xstat_mtime_dir(&st);
180 if (match_stat_data(&base, &st)) {
181 fputc('\n', stderr__stderrp);
182 fprintf_ln(stderr__stderrp, _("directory stat info changes after "
183 "adding a file inside subdirectory"));
184 goto done;
185 }
186 fputc('.', stderr__stderrp);
187
188 avoid_racy();
189 xunlink("newfile");
190 xstat_mtime_dir(&st);
191 if (!match_stat_data(&base, &st)) {
192 fputc('\n', stderr__stderrp);
193 fprintf_ln(stderr__stderrp, _("directory stat info does not "
194 "change after deleting a file"));
195 goto done;
196 }
197 fill_stat_data(&base, &st);
198 fputc('.', stderr__stderrp);
199
200 avoid_racy();
201 xunlink("new-dir/new");
202 xrmdir("new-dir");
203 xstat_mtime_dir(&st);
204 if (!match_stat_data(&base, &st)) {
205 fputc('\n', stderr__stderrp);
206 fprintf_ln(stderr__stderrp, _("directory stat info does not "
207 "change after deleting a directory"));
208 goto done;
209 }
210
211 if (rmdir(mtime_dir.buf))
212 die_errno(_("failed to delete directory %s"), mtime_dir.buf);
213 fprintf_ln(stderr__stderrp, _(" OK"));
214 ret = 1;
215
216done:
217 strbuf_release(&mtime_dir);
218 return ret;
219}
220
221static int mark_ce_flags(const char *path, int flag, int mark)
222{
223 int namelen = strlen(path);
224 int pos = cache_name_pos(path, namelen)index_name_pos(&the_index,(path),(namelen));
225 if (0 <= pos) {
226 if (mark)
227 active_cache(the_index.cache)[pos]->ce_flags |= flag;
228 else
229 active_cache(the_index.cache)[pos]->ce_flags &= ~flag;
230 active_cache(the_index.cache)[pos]->ce_flags |= CE_UPDATE_IN_BASE(1 << 27);
231 cache_tree_invalidate_path(&the_index, path);
232 active_cache_changed(the_index.cache_changed) |= CE_ENTRY_CHANGED(1 << 1);
233 return 0;
234 }
235 return -1;
236}
237
238static int remove_one_path(const char *path)
239{
240 if (!allow_remove)
241 return error("%s: does not exist and --remove not passed", path)(error("%s: does not exist and --remove not passed", path), const_error
());
242 if (remove_file_from_cache(path)remove_file_from_index(&the_index, (path)))
243 return error("%s: cannot remove from the index", path)(error("%s: cannot remove from the index", path), const_error
());
244 return 0;
245}
246
247/*
248 * Handle a path that couldn't be lstat'ed. It's either:
249 * - missing file (ENOENT or ENOTDIR). That's ok if we're
250 * supposed to be removing it and the removal actually
251 * succeeds.
252 * - permission error. That's never ok.
253 */
254static int process_lstat_error(const char *path, int err)
255{
256 if (err == ENOENT2 || err == ENOTDIR20)
257 return remove_one_path(path);
258 return error("lstat(\"%s\"): %s", path, strerror(err))(error("lstat(\"%s\"): %s", path, strerror(err)), const_error
());
259}
260
261static int add_one_path(const struct cache_entry *old, const char *path, int len, struct stat *st)
262{
263 int option, size;
264 struct cache_entry *ce;
265
266 /* Was the old index entry already up-to-date? */
267 if (old && !ce_stage(old)(((0x3000) & (old)->ce_flags) >> 12) && !ce_match_stat(old, st, 0)ie_match_stat(&the_index, (old), (st), (0)))
268 return 0;
269
270 size = cache_entry_size(len)(__builtin_offsetof(struct cache_entry, name) + (len) + 1);
271 ce = xcalloc(1, size);
272 memcpy(ce->name, path, len)__builtin___memcpy_chk (ce->name, path, len, __builtin_object_size
(ce->name, 0));
273 ce->ce_flags = create_ce_flags(0);
274 ce->ce_namelen = len;
275 fill_stat_cache_info(ce, st);
276 ce->ce_mode = ce_mode_from_stat(old, st->st_mode);
277
278 if (index_path(ce->oid.hash, path, st,
279 info_only ? 0 : HASH_WRITE_OBJECT1)) {
280 free(ce);
281 return -1;
282 }
283 option = allow_add ? ADD_CACHE_OK_TO_ADD1 : 0;
284 option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE2 : 0;
285 if (add_cache_entry(ce, option)add_index_entry(&the_index, (ce), (option)))
286 return error("%s: cannot add to the index - missing --add option?", path)(error("%s: cannot add to the index - missing --add option?",
path), const_error());
287 return 0;
288}
289
290/*
291 * Handle a path that was a directory. Four cases:
292 *
293 * - it's already a gitlink in the index, and we keep it that
294 * way, and update it if we can (if we cannot find the HEAD,
295 * we're going to keep it unchanged in the index!)
296 *
297 * - it's a *file* in the index, in which case it should be
298 * removed as a file if removal is allowed, since it doesn't
299 * exist as such any more. If removal isn't allowed, it's
300 * an error.
301 *
302 * (NOTE! This is old and arguably fairly strange behaviour.
303 * We might want to make this an error unconditionally, and
304 * use "--force-remove" if you actually want to force removal).
305 *
306 * - it used to exist as a subdirectory (ie multiple files with
307 * this particular prefix) in the index, in which case it's wrong
308 * to try to update it as a directory.
309 *
310 * - it doesn't exist at all in the index, but it is a valid
311 * git directory, and it should be *added* as a gitlink.
312 */
313static int process_directory(const char *path, int len, struct stat *st)
314{
315 struct object_id oid;
316 int pos = cache_name_pos(path, len)index_name_pos(&the_index,(path),(len));
317
318 /* Exact match: file or existing gitlink */
319 if (pos >= 0) {
320 const struct cache_entry *ce = active_cache(the_index.cache)[pos];
321 if (S_ISGITLINK(ce->ce_mode)(((ce->ce_mode) & 0170000) == 0160000)) {
322
323 /* Do nothing to the index if there is no HEAD! */
324 if (resolve_gitlink_ref(path, "HEAD", oid.hash) < 0)
325 return 0;
326
327 return add_one_path(ce, path, len, st);
328 }
329 /* Should this be an unconditional error? */
330 return remove_one_path(path);
331 }
332
333 /* Inexact match: is there perhaps a subdirectory match? */
334 pos = -pos-1;
335 while (pos < active_nr(the_index.cache_nr)) {
336 const struct cache_entry *ce = active_cache(the_index.cache)[pos++];
337
338 if (strncmp(ce->name, path, len))
339 break;
340 if (ce->name[len] > '/')
341 break;
342 if (ce->name[len] < '/')
343 continue;
344
345 /* Subdirectory match - error out */
346 return error("%s: is a directory - add individual files instead", path)(error("%s: is a directory - add individual files instead", path
), const_error());
347 }
348
349 /* No match - should we add it as a gitlink? */
350 if (!resolve_gitlink_ref(path, "HEAD", oid.hash))
351 return add_one_path(NULL((void*)0), path, len, st);
352
353 /* Error out. */
354 return error("%s: is a directory - add files inside instead", path)(error("%s: is a directory - add files inside instead", path)
, const_error());
355}
356
357static int process_path(const char *path)
358{
359 int pos, len;
360 struct stat st;
361 const struct cache_entry *ce;
362
363 len = strlen(path);
364 if (has_symlink_leading_path(path, len))
365 return error("'%s' is beyond a symbolic link", path)(error("'%s' is beyond a symbolic link", path), const_error()
);
366
367 pos = cache_name_pos(path, len)index_name_pos(&the_index,(path),(len));
368 ce = pos < 0 ? NULL((void*)0) : active_cache(the_index.cache)[pos];
369 if (ce && ce_skip_worktree(ce)((ce)->ce_flags & (1 << 30))) {
370 /*
371 * working directory version is assumed "good"
372 * so updating it does not make sense.
373 * On the other hand, removing it from index should work
374 */
375 if (allow_remove && remove_file_from_cache(path)remove_file_from_index(&the_index, (path)))
376 return error("%s: cannot remove from the index", path)(error("%s: cannot remove from the index", path), const_error
());
377 return 0;
378 }
379
380 /*
381 * First things first: get the stat information, to decide
382 * what to do about the pathname!
383 */
384 if (lstat(path, &st) < 0)
385 return process_lstat_error(path, errno(*__error()));
386
387 if (S_ISDIR(st.st_mode)(((st.st_mode) & 0170000) == 0040000))
388 return process_directory(path, len, &st);
389
390 return add_one_path(ce, path, len, &st);
391}
392
393static int add_cacheinfo(unsigned int mode, const struct object_id *oid,
394 const char *path, int stage)
395{
396 int size, len, option;
397 struct cache_entry *ce;
398
399 if (!verify_path(path))
400 return error("Invalid path '%s'", path)(error("Invalid path '%s'", path), const_error());
401
402 len = strlen(path);
403 size = cache_entry_size(len)(__builtin_offsetof(struct cache_entry, name) + (len) + 1);
404 ce = xcalloc(1, size);
405
406 oidcpy(&ce->oid, oid);
407 memcpy(ce->name, path, len)__builtin___memcpy_chk (ce->name, path, len, __builtin_object_size
(ce->name, 0));
408 ce->ce_flags = create_ce_flags(stage);
409 ce->ce_namelen = len;
410 ce->ce_mode = create_ce_mode(mode);
411 if (assume_unchanged)
412 ce->ce_flags |= CE_VALID(0x8000);
413 option = allow_add ? ADD_CACHE_OK_TO_ADD1 : 0;
414 option |= allow_replace ? ADD_CACHE_OK_TO_REPLACE2 : 0;
415 if (add_cache_entry(ce, option)add_index_entry(&the_index, (ce), (option)))
416 return error("%s: cannot add to the index - missing --add option?",(error("%s: cannot add to the index - missing --add option?",
path), const_error())
417 path)(error("%s: cannot add to the index - missing --add option?",
path), const_error());
418 report("add '%s'", path);
419 return 0;
420}
421
422static void chmod_path(char flip, const char *path)
423{
424 int pos;
425 struct cache_entry *ce;
426
427 pos = cache_name_pos(path, strlen(path))index_name_pos(&the_index,(path),(strlen(path)));
428 if (pos < 0)
429 goto fail;
430 ce = active_cache(the_index.cache)[pos];
431 if (chmod_cache_entry(ce, flip)chmod_index_entry(&the_index, (ce), (flip)) < 0)
432 goto fail;
433
434 report("chmod %cx '%s'", flip, path);
435 return;
436 fail:
437 die("git update-index: cannot chmod %cx '%s'", flip, path);
438}
439
440static void update_one(const char *path)
441{
442 if (!verify_path(path)) {
443 fprintf(stderr__stderrp, "Ignoring path %s\n", path);
444 return;
445 }
446 if (mark_valid_only) {
447 if (mark_ce_flags(path, CE_VALID(0x8000), mark_valid_only == MARK_FLAG1))
448 die("Unable to mark file %s", path);
449 return;
450 }
451 if (mark_skip_worktree_only) {
452 if (mark_ce_flags(path, CE_SKIP_WORKTREE(1 << 30), mark_skip_worktree_only == MARK_FLAG1))
453 die("Unable to mark file %s", path);
454 return;
455 }
456
457 if (force_remove) {
458 if (remove_file_from_cache(path)remove_file_from_index(&the_index, (path)))
459 die("git update-index: unable to remove %s", path);
460 report("remove '%s'", path);
461 return;
462 }
463 if (process_path(path))
464 die("Unable to process path %s", path);
465 report("add '%s'", path);
466}
467
468static void read_index_info(int nul_term_line)
469{
470 struct strbuf buf = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
471 struct strbuf uq = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
472 strbuf_getline_fn getline_fn;
473
474 getline_fn = nul_term_line ? strbuf_getline_nul : strbuf_getline_lf;
475 while (getline_fn(&buf, stdin__stdinp) != EOF(-1)) {
476 char *ptr, *tab;
477 char *path_name;
478 struct object_id oid;
479 unsigned int mode;
480 unsigned long ul;
481 int stage;
482
483 /* This reads lines formatted in one of three formats:
484 *
485 * (1) mode SP sha1 TAB path
486 * The first format is what "git apply --index-info"
487 * reports, and used to reconstruct a partial tree
488 * that is used for phony merge base tree when falling
489 * back on 3-way merge.
490 *
491 * (2) mode SP type SP sha1 TAB path
492 * The second format is to stuff "git ls-tree" output
493 * into the index file.
494 *
495 * (3) mode SP sha1 SP stage TAB path
496 * This format is to put higher order stages into the
497 * index file and matches "git ls-files --stage" output.
498 */
499 errno(*__error()) = 0;
500 ul = strtoul(buf.buf, &ptr, 8);
501 if (ptr == buf.buf || *ptr != ' '
502 || errno(*__error()) || (unsigned int) ul != ul)
503 goto bad_line;
504 mode = ul;
505
506 tab = strchr(ptr, '\t');
507 if (!tab || tab - ptr < GIT_SHA1_HEXSZ(2 * 20) + 1)
508 goto bad_line;
509
510 if (tab[-2] == ' ' && '0' <= tab[-1] && tab[-1] <= '3') {
511 stage = tab[-1] - '0';
512 ptr = tab + 1; /* point at the head of path */
513 tab = tab - 2; /* point at tail of sha1 */
514 }
515 else {
516 stage = 0;
517 ptr = tab + 1; /* point at the head of path */
518 }
519
520 if (get_oid_hex(tab - GIT_SHA1_HEXSZ(2 * 20), &oid) ||
521 tab[-(GIT_SHA1_HEXSZ(2 * 20) + 1)] != ' ')
522 goto bad_line;
523
524 path_name = ptr;
525 if (!nul_term_line && path_name[0] == '"') {
526 strbuf_reset(&uq)strbuf_setlen(&uq, 0);
527 if (unquote_c_style(&uq, path_name, NULL((void*)0))) {
528 die("git update-index: bad quoting of path name");
529 }
530 path_name = uq.buf;
531 }
532
533 if (!verify_path(path_name)) {
534 fprintf(stderr__stderrp, "Ignoring path %s\n", path_name);
535 continue;
536 }
537
538 if (!mode) {
539 /* mode == 0 means there is no such path -- remove */
540 if (remove_file_from_cache(path_name)remove_file_from_index(&the_index, (path_name)))
541 die("git update-index: unable to remove %s",
542 ptr);
543 }
544 else {
545 /* mode ' ' sha1 '\t' name
546 * ptr[-1] points at tab,
547 * ptr[-41] is at the beginning of sha1
548 */
549 ptr[-(GIT_SHA1_HEXSZ(2 * 20) + 2)] = ptr[-1] = 0;
550 if (add_cacheinfo(mode, &oid, path_name, stage))
551 die("git update-index: unable to update %s",
552 path_name);
553 }
554 continue;
555
556 bad_line:
557 die("malformed index info %s", buf.buf);
558 }
559 strbuf_release(&buf);
560 strbuf_release(&uq);
561}
562
563static const char * const update_index_usage[] = {
564 N_("git update-index [<options>] [--] [<file>...]")("git update-index [<options>] [--] [<file>...]"),
565 NULL((void*)0)
566};
567
568static struct object_id head_oid;
569static struct object_id merge_head_oid;
570
571static struct cache_entry *read_one_ent(const char *which,
572 struct object_id *ent, const char *path,
573 int namelen, int stage)
574{
575 unsigned mode;
576 struct object_id oid;
577 int size;
578 struct cache_entry *ce;
579
580 if (get_tree_entry(ent->hash, path, oid.hash, &mode)) {
581 if (which)
582 error("%s: not in %s branch.", path, which)(error("%s: not in %s branch.", path, which), const_error());
583 return NULL((void*)0);
584 }
585 if (mode == S_IFDIR0040000) {
586 if (which)
587 error("%s: not a blob in %s branch.", path, which)(error("%s: not a blob in %s branch.", path, which), const_error
());
588 return NULL((void*)0);
589 }
590 size = cache_entry_size(namelen)(__builtin_offsetof(struct cache_entry, name) + (namelen) + 1
);
591 ce = xcalloc(1, size);
592
593 oidcpy(&ce->oid, &oid);
594 memcpy(ce->name, path, namelen)__builtin___memcpy_chk (ce->name, path, namelen, __builtin_object_size
(ce->name, 0));
595 ce->ce_flags = create_ce_flags(stage);
596 ce->ce_namelen = namelen;
597 ce->ce_mode = create_ce_mode(mode);
598 return ce;
599}
600
601static int unresolve_one(const char *path)
602{
603 int namelen = strlen(path);
604 int pos;
605 int ret = 0;
606 struct cache_entry *ce_2 = NULL((void*)0), *ce_3 = NULL((void*)0);
607
608 /* See if there is such entry in the index. */
609 pos = cache_name_pos(path, namelen)index_name_pos(&the_index,(path),(namelen));
610 if (0 <= pos) {
611 /* already merged */
612 pos = unmerge_cache_entry_at(pos)unmerge_index_entry_at(&the_index, pos);
613 if (pos < active_nr(the_index.cache_nr)) {
614 const struct cache_entry *ce = active_cache(the_index.cache)[pos];
615 if (ce_stage(ce)(((0x3000) & (ce)->ce_flags) >> 12) &&
616 ce_namelen(ce)((ce)->ce_namelen) == namelen &&
617 !memcmp(ce->name, path, namelen))
618 return 0;
619 }
620 /* no resolve-undo information; fall back */
621 } else {
622 /* If there isn't, either it is unmerged, or
623 * resolved as "removed" by mistake. We do not
624 * want to do anything in the former case.
625 */
626 pos = -pos-1;
627 if (pos < active_nr(the_index.cache_nr)) {
628 const struct cache_entry *ce = active_cache(the_index.cache)[pos];
629 if (ce_namelen(ce)((ce)->ce_namelen) == namelen &&
630 !memcmp(ce->name, path, namelen)) {
631 fprintf(stderr__stderrp,
632 "%s: skipping still unmerged path.\n",
633 path);
634 goto free_return;
635 }
636 }
637 }
638
639 /* Grab blobs from given path from HEAD and MERGE_HEAD,
640 * stuff HEAD version in stage #2,
641 * stuff MERGE_HEAD version in stage #3.
642 */
643 ce_2 = read_one_ent("our", &head_oid, path, namelen, 2);
644 ce_3 = read_one_ent("their", &merge_head_oid, path, namelen, 3);
645
646 if (!ce_2 || !ce_3) {
647 ret = -1;
648 goto free_return;
649 }
650 if (!oidcmp(&ce_2->oid, &ce_3->oid) &&
651 ce_2->ce_mode == ce_3->ce_mode) {
652 fprintf(stderr__stderrp, "%s: identical in both, skipping.\n",
653 path);
654 goto free_return;
655 }
656
657 remove_file_from_cache(path)remove_file_from_index(&the_index, (path));
658 if (add_cache_entry(ce_2, ADD_CACHE_OK_TO_ADD)add_index_entry(&the_index, (ce_2), (1))) {
659 error("%s: cannot add our version to the index.", path)(error("%s: cannot add our version to the index.", path), const_error
());
660 ret = -1;
661 goto free_return;
662 }
663 if (!add_cache_entry(ce_3, ADD_CACHE_OK_TO_ADD)add_index_entry(&the_index, (ce_3), (1)))
664 return 0;
665 error("%s: cannot add their version to the index.", path)(error("%s: cannot add their version to the index.", path), const_error
());
666 ret = -1;
667 free_return:
668 free(ce_2);
669 free(ce_3);
670 return ret;
671}
672
673static void read_head_pointers(void)
674{
675 if (read_ref("HEAD", head_oid.hash))
676 die("No HEAD -- no initial commit yet?");
677 if (read_ref("MERGE_HEAD", merge_head_oid.hash)) {
678 fprintf(stderr__stderrp, "Not in the middle of a merge.\n");
679 exit(0);
680 }
681}
682
683static int do_unresolve(int ac, const char **av,
684 const char *prefix, int prefix_length)
685{
686 int i;
687 int err = 0;
688
689 /* Read HEAD and MERGE_HEAD; if MERGE_HEAD does not exist, we
690 * are not doing a merge, so exit with success status.
691 */
692 read_head_pointers();
693
694 for (i = 1; i < ac; i++) {
695 const char *arg = av[i];
696 char *p = prefix_path(prefix, prefix_length, arg);
697 err |= unresolve_one(p);
698 free(p);
699 }
700 return err;
701}
702
703static int do_reupdate(int ac, const char **av,
704 const char *prefix, int prefix_length)
705{
706 /* Read HEAD and run update-index on paths that are
707 * merged and already different between index and HEAD.
708 */
709 int pos;
710 int has_head = 1;
711 struct pathspec pathspec;
712
713 parse_pathspec(&pathspec, 0,
714 PATHSPEC_PREFER_CWD(1<<0),
715 prefix, av + 1);
716
717 if (read_ref("HEAD", head_oid.hash))
718 /* If there is no HEAD, that means it is an initial
719 * commit. Update everything in the index.
720 */
721 has_head = 0;
722 redo:
723 for (pos = 0; pos < active_nr(the_index.cache_nr); pos++) {
724 const struct cache_entry *ce = active_cache(the_index.cache)[pos];
725 struct cache_entry *old = NULL((void*)0);
726 int save_nr;
727 char *path;
728
729 if (ce_stage(ce)(((0x3000) & (ce)->ce_flags) >> 12) || !ce_path_match(ce, &pathspec, NULL((void*)0)))
730 continue;
731 if (has_head)
732 old = read_one_ent(NULL((void*)0), &head_oid,
733 ce->name, ce_namelen(ce)((ce)->ce_namelen), 0);
734 if (old && ce->ce_mode == old->ce_mode &&
735 !oidcmp(&ce->oid, &old->oid)) {
736 free(old);
737 continue; /* unchanged */
738 }
739 /* Be careful. The working tree may not have the
740 * path anymore, in which case, under 'allow_remove',
741 * or worse yet 'allow_replace', active_nr may decrease.
742 */
743 save_nr = active_nr(the_index.cache_nr);
744 path = xstrdup(ce->name);
745 update_one(path);
746 free(path);
747 free(old);
748 if (save_nr != active_nr(the_index.cache_nr))
749 goto redo;
750 }
751 clear_pathspec(&pathspec);
752 return 0;
753}
754
755struct refresh_params {
756 unsigned int flags;
757 int *has_errors;
758};
759
760static int refresh(struct refresh_params *o, unsigned int flag)
761{
762 setup_work_tree();
763 read_cache_preload(NULL)read_index_preload(&the_index, (((void*)0)));
764 *o->has_errors |= refresh_cache(o->flags | flag)refresh_index(&the_index, (o->flags | flag), ((void*)0
), ((void*)0), ((void*)0));
765 return 0;
766}
767
768static int refresh_callback(const struct option *opt,
769 const char *arg, int unset)
770{
771 return refresh(opt->value, 0);
772}
773
774static int really_refresh_callback(const struct option *opt,
775 const char *arg, int unset)
776{
777 return refresh(opt->value, REFRESH_REALLY0x0001);
778}
779
780static int chmod_callback(const struct option *opt,
781 const char *arg, int unset)
782{
783 char *flip = opt->value;
784 if ((arg[0] != '-' && arg[0] != '+') || arg[1] != 'x' || arg[2])
785 return error("option 'chmod' expects \"+x\" or \"-x\"")(error("option 'chmod' expects \"+x\" or \"-x\""), const_error
());
786 *flip = arg[0];
787 return 0;
788}
789
790static int resolve_undo_clear_callback(const struct option *opt,
791 const char *arg, int unset)
792{
793 resolve_undo_clear()resolve_undo_clear_index(&the_index);
794 return 0;
795}
796
797static int parse_new_style_cacheinfo(const char *arg,
798 unsigned int *mode,
799 struct object_id *oid,
800 const char **path)
801{
802 unsigned long ul;
803 char *endp;
804
805 if (!arg)
806 return -1;
807
808 errno(*__error()) = 0;
809 ul = strtoul(arg, &endp, 8);
810 if (errno(*__error()) || endp == arg || *endp != ',' || (unsigned int) ul != ul)
811 return -1; /* not a new-style cacheinfo */
812 *mode = ul;
813 endp++;
814 if (get_oid_hex(endp, oid) || endp[GIT_SHA1_HEXSZ(2 * 20)] != ',')
815 return -1;
816 *path = endp + GIT_SHA1_HEXSZ(2 * 20) + 1;
817 return 0;
818}
819
820static int cacheinfo_callback(struct parse_opt_ctx_t *ctx,
821 const struct option *opt, int unset)
822{
823 struct object_id oid;
824 unsigned int mode;
825 const char *path;
826
827 if (!parse_new_style_cacheinfo(ctx->argv[1], &mode, &oid, &path)) {
828 if (add_cacheinfo(mode, &oid, path, 0))
829 die("git update-index: --cacheinfo cannot add %s", path);
830 ctx->argv++;
831 ctx->argc--;
832 return 0;
833 }
834 if (ctx->argc <= 3)
835 return error("option 'cacheinfo' expects <mode>,<sha1>,<path>")(error("option 'cacheinfo' expects <mode>,<sha1>,<path>"
), const_error());
836 if (strtoul_ui(*++ctx->argv, 8, &mode) ||
837 get_oid_hex(*++ctx->argv, &oid) ||
838 add_cacheinfo(mode, &oid, *++ctx->argv, 0))
839 die("git update-index: --cacheinfo cannot add %s", *ctx->argv);
840 ctx->argc -= 3;
841 return 0;
842}
843
844static int stdin_cacheinfo_callback(struct parse_opt_ctx_t *ctx,
845 const struct option *opt, int unset)
846{
847 int *nul_term_line = opt->value;
848
849 if (ctx->argc != 1)
850 return error("option '%s' must be the last argument", opt->long_name)(error("option '%s' must be the last argument", opt->long_name
), const_error());
851 allow_add = allow_replace = allow_remove = 1;
852 read_index_info(*nul_term_line);
853 return 0;
854}
855
856static int stdin_callback(struct parse_opt_ctx_t *ctx,
857 const struct option *opt, int unset)
858{
859 int *read_from_stdin = opt->value;
860
861 if (ctx->argc != 1)
862 return error("option '%s' must be the last argument", opt->long_name)(error("option '%s' must be the last argument", opt->long_name
), const_error());
863 *read_from_stdin = 1;
864 return 0;
865}
866
867static int unresolve_callback(struct parse_opt_ctx_t *ctx,
868 const struct option *opt, int flags)
869{
870 int *has_errors = opt->value;
871 const char *prefix = startup_info->prefix;
872
873 /* consume remaining arguments. */
874 *has_errors = do_unresolve(ctx->argc, ctx->argv,
875 prefix, prefix ? strlen(prefix) : 0);
876 if (*has_errors)
877 active_cache_changed(the_index.cache_changed) = 0;
878
879 ctx->argv += ctx->argc - 1;
880 ctx->argc = 1;
881 return 0;
882}
883
884static int reupdate_callback(struct parse_opt_ctx_t *ctx,
885 const struct option *opt, int flags)
886{
887 int *has_errors = opt->value;
888 const char *prefix = startup_info->prefix;
889
890 /* consume remaining arguments. */
891 setup_work_tree();
892 *has_errors = do_reupdate(ctx->argc, ctx->argv,
893 prefix, prefix ? strlen(prefix) : 0);
894 if (*has_errors)
895 active_cache_changed(the_index.cache_changed) = 0;
896
897 ctx->argv += ctx->argc - 1;
898 ctx->argc = 1;
899 return 0;
900}
901
902int cmd_update_index(int argc, const char **argv, const char *prefix)
903{
904 int newfd, entries, has_errors = 0, nul_term_line = 0;
905 enum uc_mode untracked_cache = UC_UNSPECIFIED;
906 int read_from_stdin = 0;
907 int prefix_length = prefix ? strlen(prefix) : 0;
908 int preferred_index_format = 0;
909 char set_executable_bit = 0;
910 struct refresh_params refresh_args = {0, &has_errors};
911 int lock_error = 0;
912 int split_index = -1;
913 struct lock_file *lock_file;
914 struct parse_opt_ctx_t ctx;
915 strbuf_getline_fn getline_fn;
916 int parseopt_state = PARSE_OPT_UNKNOWN;
917 struct option options[] = {
918 OPT_BIT('q', NULL, &refresh_args.flags,{ OPTION_BIT, ('q'), (((void*)0)), (&refresh_args.flags),
((void*)0), (("continue refresh even when index needs update"
)), PARSE_OPT_NOARG, ((void*)0), (0x0004) }
919 N_("continue refresh even when index needs update"),{ OPTION_BIT, ('q'), (((void*)0)), (&refresh_args.flags),
((void*)0), (("continue refresh even when index needs update"
)), PARSE_OPT_NOARG, ((void*)0), (0x0004) }
920 REFRESH_QUIET){ OPTION_BIT, ('q'), (((void*)0)), (&refresh_args.flags),
((void*)0), (("continue refresh even when index needs update"
)), PARSE_OPT_NOARG, ((void*)0), (0x0004) },
921 OPT_BIT(0, "ignore-submodules", &refresh_args.flags,{ OPTION_BIT, (0), ("ignore-submodules"), (&refresh_args.
flags), ((void*)0), (("refresh: ignore submodules")), PARSE_OPT_NOARG
, ((void*)0), (0x0010) }
922 N_("refresh: ignore submodules"),{ OPTION_BIT, (0), ("ignore-submodules"), (&refresh_args.
flags), ((void*)0), (("refresh: ignore submodules")), PARSE_OPT_NOARG
, ((void*)0), (0x0010) }
923 REFRESH_IGNORE_SUBMODULES){ OPTION_BIT, (0), ("ignore-submodules"), (&refresh_args.
flags), ((void*)0), (("refresh: ignore submodules")), PARSE_OPT_NOARG
, ((void*)0), (0x0010) },
924 OPT_SET_INT(0, "add", &allow_add,{ OPTION_SET_INT, (0), ("add"), (&allow_add), ((void*)0),
(("do not ignore new files")), PARSE_OPT_NOARG, ((void*)0), (
1) }
925 N_("do not ignore new files"), 1){ OPTION_SET_INT, (0), ("add"), (&allow_add), ((void*)0),
(("do not ignore new files")), PARSE_OPT_NOARG, ((void*)0), (
1) },
926 OPT_SET_INT(0, "replace", &allow_replace,{ OPTION_SET_INT, (0), ("replace"), (&allow_replace), ((void
*)0), (("let files replace directories and vice-versa")), PARSE_OPT_NOARG
, ((void*)0), (1) }
927 N_("let files replace directories and vice-versa"), 1){ OPTION_SET_INT, (0), ("replace"), (&allow_replace), ((void
*)0), (("let files replace directories and vice-versa")), PARSE_OPT_NOARG
, ((void*)0), (1) },
928 OPT_SET_INT(0, "remove", &allow_remove,{ OPTION_SET_INT, (0), ("remove"), (&allow_remove), ((void
*)0), (("notice files missing from worktree")), PARSE_OPT_NOARG
, ((void*)0), (1) }
929 N_("notice files missing from worktree"), 1){ OPTION_SET_INT, (0), ("remove"), (&allow_remove), ((void
*)0), (("notice files missing from worktree")), PARSE_OPT_NOARG
, ((void*)0), (1) },
930 OPT_BIT(0, "unmerged", &refresh_args.flags,{ OPTION_BIT, (0), ("unmerged"), (&refresh_args.flags), (
(void*)0), (("refresh even if index contains unmerged entries"
)), PARSE_OPT_NOARG, ((void*)0), (0x0002) }
931 N_("refresh even if index contains unmerged entries"),{ OPTION_BIT, (0), ("unmerged"), (&refresh_args.flags), (
(void*)0), (("refresh even if index contains unmerged entries"
)), PARSE_OPT_NOARG, ((void*)0), (0x0002) }
932 REFRESH_UNMERGED){ OPTION_BIT, (0), ("unmerged"), (&refresh_args.flags), (
(void*)0), (("refresh even if index contains unmerged entries"
)), PARSE_OPT_NOARG, ((void*)0), (0x0002) },
933 {OPTION_CALLBACK, 0, "refresh", &refresh_args, NULL((void*)0),
934 N_("refresh stat information")("refresh stat information"),
935 PARSE_OPT_NOARG | PARSE_OPT_NONEG,
936 refresh_callback},
937 {OPTION_CALLBACK, 0, "really-refresh", &refresh_args, NULL((void*)0),
938 N_("like --refresh, but ignore assume-unchanged setting")("like --refresh, but ignore assume-unchanged setting"),
939 PARSE_OPT_NOARG | PARSE_OPT_NONEG,
940 really_refresh_callback},
941 {OPTION_LOWLEVEL_CALLBACK, 0, "cacheinfo", NULL((void*)0),
942 N_("<mode>,<object>,<path>")("<mode>,<object>,<path>"),
943 N_("add the specified entry to the index")("add the specified entry to the index"),
944 PARSE_OPT_NOARG | /* disallow --cacheinfo=<mode> form */
945 PARSE_OPT_NONEG | PARSE_OPT_LITERAL_ARGHELP,
946 (parse_opt_cb *) cacheinfo_callback},
947 {OPTION_CALLBACK, 0, "chmod", &set_executable_bit, N_("(+/-)x")("(+/-)x"),
948 N_("override the executable bit of the listed files")("override the executable bit of the listed files"),
949 PARSE_OPT_NONEG | PARSE_OPT_LITERAL_ARGHELP,
950 chmod_callback},
951 {OPTION_SET_INT, 0, "assume-unchanged", &mark_valid_only, NULL((void*)0),
952 N_("mark files as \"not changing\"")("mark files as \"not changing\""),
953 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL((void*)0), MARK_FLAG1},
954 {OPTION_SET_INT, 0, "no-assume-unchanged", &mark_valid_only, NULL((void*)0),
955 N_("clear assumed-unchanged bit")("clear assumed-unchanged bit"),
956 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL((void*)0), UNMARK_FLAG2},
957 {OPTION_SET_INT, 0, "skip-worktree", &mark_skip_worktree_only, NULL((void*)0),
958 N_("mark files as \"index-only\"")("mark files as \"index-only\""),
959 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL((void*)0), MARK_FLAG1},
960 {OPTION_SET_INT, 0, "no-skip-worktree", &mark_skip_worktree_only, NULL((void*)0),
961 N_("clear skip-worktree bit")("clear skip-worktree bit"),
962 PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL((void*)0), UNMARK_FLAG2},
963 OPT_SET_INT(0, "info-only", &info_only,{ OPTION_SET_INT, (0), ("info-only"), (&info_only), ((void
*)0), (("add to index only; do not add content to object database"
)), PARSE_OPT_NOARG, ((void*)0), (1) }
964 N_("add to index only; do not add content to object database"), 1){ OPTION_SET_INT, (0), ("info-only"), (&info_only), ((void
*)0), (("add to index only; do not add content to object database"
)), PARSE_OPT_NOARG, ((void*)0), (1) },
965 OPT_SET_INT(0, "force-remove", &force_remove,{ OPTION_SET_INT, (0), ("force-remove"), (&force_remove),
((void*)0), (("remove named paths even if present in worktree"
)), PARSE_OPT_NOARG, ((void*)0), (1) }
966 N_("remove named paths even if present in worktree"), 1){ OPTION_SET_INT, (0), ("force-remove"), (&force_remove),
((void*)0), (("remove named paths even if present in worktree"
)), PARSE_OPT_NOARG, ((void*)0), (1) },
967 OPT_BOOL('z', NULL, &nul_term_line,{ OPTION_SET_INT, ('z'), (((void*)0)), (&nul_term_line), (
(void*)0), (("with --stdin: input lines are terminated by null bytes"
)), PARSE_OPT_NOARG, ((void*)0), (1) }
968 N_("with --stdin: input lines are terminated by null bytes")){ OPTION_SET_INT, ('z'), (((void*)0)), (&nul_term_line), (
(void*)0), (("with --stdin: input lines are terminated by null bytes"
)), PARSE_OPT_NOARG, ((void*)0), (1) },
969 {OPTION_LOWLEVEL_CALLBACK, 0, "stdin", &read_from_stdin, NULL((void*)0),
970 N_("read list of paths to be updated from standard input")("read list of paths to be updated from standard input"),
971 PARSE_OPT_NONEG | PARSE_OPT_NOARG,
972 (parse_opt_cb *) stdin_callback},
973 {OPTION_LOWLEVEL_CALLBACK, 0, "index-info", &nul_term_line, NULL((void*)0),
974 N_("add entries from standard input to the index")("add entries from standard input to the index"),
975 PARSE_OPT_NONEG | PARSE_OPT_NOARG,
976 (parse_opt_cb *) stdin_cacheinfo_callback},
977 {OPTION_LOWLEVEL_CALLBACK, 0, "unresolve", &has_errors, NULL((void*)0),
978 N_("repopulate stages #2 and #3 for the listed paths")("repopulate stages #2 and #3 for the listed paths"),
979 PARSE_OPT_NONEG | PARSE_OPT_NOARG,
980 (parse_opt_cb *) unresolve_callback},
981 {OPTION_LOWLEVEL_CALLBACK, 'g', "again", &has_errors, NULL((void*)0),
982 N_("only update entries that differ from HEAD")("only update entries that differ from HEAD"),
983 PARSE_OPT_NONEG | PARSE_OPT_NOARG,
984 (parse_opt_cb *) reupdate_callback},
985 OPT_BIT(0, "ignore-missing", &refresh_args.flags,{ OPTION_BIT, (0), ("ignore-missing"), (&refresh_args.flags
), ((void*)0), (("ignore files missing from worktree")), PARSE_OPT_NOARG
, ((void*)0), (0x0008) }
986 N_("ignore files missing from worktree"),{ OPTION_BIT, (0), ("ignore-missing"), (&refresh_args.flags
), ((void*)0), (("ignore files missing from worktree")), PARSE_OPT_NOARG
, ((void*)0), (0x0008) }
987 REFRESH_IGNORE_MISSING){ OPTION_BIT, (0), ("ignore-missing"), (&refresh_args.flags
), ((void*)0), (("ignore files missing from worktree")), PARSE_OPT_NOARG
, ((void*)0), (0x0008) },
988 OPT_SET_INT(0, "verbose", &verbose,{ OPTION_SET_INT, (0), ("verbose"), (&verbose), ((void*)0
), (("report actions to standard output")), PARSE_OPT_NOARG, (
(void*)0), (1) }
989 N_("report actions to standard output"), 1){ OPTION_SET_INT, (0), ("verbose"), (&verbose), ((void*)0
), (("report actions to standard output")), PARSE_OPT_NOARG, (
(void*)0), (1) },
990 {OPTION_CALLBACK, 0, "clear-resolve-undo", NULL((void*)0), NULL((void*)0),
991 N_("(for porcelains) forget saved unresolved conflicts")("(for porcelains) forget saved unresolved conflicts"),
992 PARSE_OPT_NOARG | PARSE_OPT_NONEG,
993 resolve_undo_clear_callback},
994 OPT_INTEGER(0, "index-version", &preferred_index_format,{ OPTION_INTEGER, (0), ("index-version"), (&preferred_index_format
), ("n"), (("write index in this format")) }
995 N_("write index in this format")){ OPTION_INTEGER, (0), ("index-version"), (&preferred_index_format
), ("n"), (("write index in this format")) },
996 OPT_BOOL(0, "split-index", &split_index,{ OPTION_SET_INT, (0), ("split-index"), (&split_index), (
(void*)0), (("enable or disable split index")), PARSE_OPT_NOARG
, ((void*)0), (1) }
997 N_("enable or disable split index")){ OPTION_SET_INT, (0), ("split-index"), (&split_index), (
(void*)0), (("enable or disable split index")), PARSE_OPT_NOARG
, ((void*)0), (1) },
998 OPT_BOOL(0, "untracked-cache", &untracked_cache,{ OPTION_SET_INT, (0), ("untracked-cache"), (&untracked_cache
), ((void*)0), (("enable/disable untracked cache")), PARSE_OPT_NOARG
, ((void*)0), (1) }
999 N_("enable/disable untracked cache")){ OPTION_SET_INT, (0), ("untracked-cache"), (&untracked_cache
), ((void*)0), (("enable/disable untracked cache")), PARSE_OPT_NOARG
, ((void*)0), (1) },
1000 OPT_SET_INT(0, "test-untracked-cache", &untracked_cache,{ OPTION_SET_INT, (0), ("test-untracked-cache"), (&untracked_cache
), ((void*)0), (("test if the filesystem supports untracked cache"
)), PARSE_OPT_NOARG, ((void*)0), (UC_TEST) }
1001 N_("test if the filesystem supports untracked cache"), UC_TEST){ OPTION_SET_INT, (0), ("test-untracked-cache"), (&untracked_cache
), ((void*)0), (("test if the filesystem supports untracked cache"
)), PARSE_OPT_NOARG, ((void*)0), (UC_TEST) },
1002 OPT_SET_INT(0, "force-untracked-cache", &untracked_cache,{ OPTION_SET_INT, (0), ("force-untracked-cache"), (&untracked_cache
), ((void*)0), (("enable untracked cache without testing the filesystem"
)), PARSE_OPT_NOARG, ((void*)0), (UC_FORCE) }
1003 N_("enable untracked cache without testing the filesystem"), UC_FORCE){ OPTION_SET_INT, (0), ("force-untracked-cache"), (&untracked_cache
), ((void*)0), (("enable untracked cache without testing the filesystem"
)), PARSE_OPT_NOARG, ((void*)0), (UC_FORCE) },
1004 OPT_END(){ OPTION_END }
1005 };
1006
1007 if (argc == 2 && !strcmp(argv[1], "-h"))
1008 usage_with_options(update_index_usage, options);
1009
1010 git_config(git_default_config, NULL((void*)0));
1011
1012 /* We can't free this memory, it becomes part of a linked list parsed atexit() */
1013 lock_file = xcalloc(1, sizeof(struct lock_file));
1014
1015 /* we will diagnose later if it turns out that we need to update it */
1016 newfd = hold_locked_index(lock_file, 0);
1017 if (newfd < 0)
1018 lock_error = errno(*__error());
1019
1020 entries = read_cache()read_index(&the_index);
1021 if (entries < 0)
1022 die("cache corrupted");
1023
1024 /*
1025 * Custom copy of parse_options() because we want to handle
1026 * filename arguments as they come.
1027 */
1028 parse_options_start(&ctx, argc, argv, prefix,
1029 options, PARSE_OPT_STOP_AT_NON_OPTION);
1030 while (ctx.argc) {
1031 if (parseopt_state != PARSE_OPT_DONE)
1032 parseopt_state = parse_options_step(&ctx, options,
1033 update_index_usage);
1034 if (!ctx.argc)
1035 break;
1036 switch (parseopt_state) {
1037 case PARSE_OPT_HELP:
1038 exit(129);
1039 case PARSE_OPT_NON_OPTION:
1040 case PARSE_OPT_DONE:
1041 {
1042 const char *path = ctx.argv[0];
1043 char *p;
1044
1045 setup_work_tree();
1046 p = prefix_path(prefix, prefix_length, path);
1047 update_one(p);
1048 if (set_executable_bit)
1049 chmod_path(set_executable_bit, p);
1050 free(p);
1051 ctx.argc--;
1052 ctx.argv++;
1053 break;
1054 }
1055 case PARSE_OPT_UNKNOWN:
1056 if (ctx.argv[0][1] == '-')
1057 error("unknown option '%s'", ctx.argv[0] + 2)(error("unknown option '%s'", ctx.argv[0] + 2), const_error()
);
1058 else
1059 error("unknown switch '%c'", *ctx.opt)(error("unknown switch '%c'", *ctx.opt), const_error());
1060 usage_with_options(update_index_usage, options);
1061 }
1062 }
1063 argc = parse_options_end(&ctx);
Value stored to 'argc' is never read
1064
1065 getline_fn = nul_term_line ? strbuf_getline_nul : strbuf_getline_lf;
1066 if (preferred_index_format) {
1067 if (preferred_index_format < INDEX_FORMAT_LB2 ||
1068 INDEX_FORMAT_UB4 < preferred_index_format)
1069 die("index-version %d not in range: %d..%d",
1070 preferred_index_format,
1071 INDEX_FORMAT_LB2, INDEX_FORMAT_UB4);
1072
1073 if (the_index.version != preferred_index_format)
1074 active_cache_changed(the_index.cache_changed) |= SOMETHING_CHANGED(1 << 0);
1075 the_index.version = preferred_index_format;
1076 }
1077
1078 if (read_from_stdin) {
1079 struct strbuf buf = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
1080 struct strbuf unquoted = STRBUF_INIT{ 0, 0, strbuf_slopbuf };
1081
1082 setup_work_tree();
1083 while (getline_fn(&buf, stdin__stdinp) != EOF(-1)) {
1084 char *p;
1085 if (!nul_term_line && buf.buf[0] == '"') {
1086 strbuf_reset(&unquoted)strbuf_setlen(&unquoted, 0);
1087 if (unquote_c_style(&unquoted, buf.buf, NULL((void*)0)))
1088 die("line is badly quoted");
1089 strbuf_swap(&buf, &unquoted);
1090 }
1091 p = prefix_path(prefix, prefix_length, buf.buf);
1092 update_one(p);
1093 if (set_executable_bit)
1094 chmod_path(set_executable_bit, p);
1095 free(p);
1096 }
1097 strbuf_release(&unquoted);
1098 strbuf_release(&buf);
1099 }
1100
1101 if (split_index > 0) {
1102 init_split_index(&the_index);
1103 the_index.cache_changed |= SPLIT_INDEX_ORDERED(1 << 6);
1104 } else if (!split_index && the_index.split_index) {
1105 /*
1106 * can't discard_split_index(&the_index); because that
1107 * will destroy split_index->base->cache[], which may
1108 * be shared with the_index.cache[]. So yeah we're
1109 * leaking a bit here.
1110 */
1111 the_index.split_index = NULL((void*)0);
1112 the_index.cache_changed |= SOMETHING_CHANGED(1 << 0);
1113 }
1114
1115 switch (untracked_cache) {
1116 case UC_UNSPECIFIED:
1117 break;
1118 case UC_DISABLE:
1119 if (git_config_get_untracked_cache() == 1)
1120 warning(_("core.untrackedCache is set to true; "
1121 "remove or change it, if you really want to "
1122 "disable the untracked cache"));
1123 remove_untracked_cache(&the_index);
1124 report(_("Untracked cache disabled"));
1125 break;
1126 case UC_TEST:
1127 setup_work_tree();
1128 return !test_if_untracked_cache_is_supported();
1129 case UC_ENABLE:
1130 case UC_FORCE:
1131 if (git_config_get_untracked_cache() == 0)
1132 warning(_("core.untrackedCache is set to false; "
1133 "remove or change it, if you really want to "
1134 "enable the untracked cache"));
1135 add_untracked_cache(&the_index);
1136 report(_("Untracked cache enabled for '%s'"), get_git_work_tree());
1137 break;
1138 default:
1139 die("BUG: bad untracked_cache value: %d", untracked_cache);
1140 }
1141
1142 if (active_cache_changed(the_index.cache_changed)) {
1143 if (newfd < 0) {
1144 if (refresh_args.flags & REFRESH_QUIET0x0004)
1145 exit(128);
1146 unable_to_lock_die(get_index_file(), lock_error);
1147 }
1148 if (write_locked_index(&the_index, lock_file, COMMIT_LOCK(1 << 0)))
1149 die("Unable to write new index file");
1150 }
1151
1152 rollback_lock_file(lock_file);
1153
1154 return has_errors ? 1 : 0;
1155}