Bug Summary

File:builtin/add.c
Location:line 214, column 2
Description:Value stored to 'argc' is never read

Annotated Source Code

1/*
2 * "git add" builtin command
3 *
4 * Copyright (C) 2006 Linus Torvalds
5 */
6#include "cache.h"
7#include "builtin.h"
8#include "lockfile.h"
9#include "dir.h"
10#include "pathspec.h"
11#include "exec_cmd.h"
12#include "cache-tree.h"
13#include "run-command.h"
14#include "parse-options.h"
15#include "diff.h"
16#include "diffcore.h"
17#include "revision.h"
18#include "bulk-checkin.h"
19#include "argv-array.h"
20
21static const char * const builtin_add_usage[] = {
22 N_("git add [<options>] [--] <pathspec>...")("git add [<options>] [--] <pathspec>..."),
23 NULL((void*)0)
24};
25static int patch_interactive, add_interactive, edit_interactive;
26static int take_worktree_changes;
27
28struct update_callback_data {
29 int flags;
30 int add_errors;
31};
32
33static void chmod_pathspec(struct pathspec *pathspec, int force_mode)
34{
35 int i;
36
37 for (i = 0; i < active_nr(the_index.cache_nr); i++) {
38 struct cache_entry *ce = active_cache(the_index.cache)[i];
39
40 if (pathspec && !ce_path_match(ce, pathspec, NULL((void*)0)))
41 continue;
42
43 if (chmod_cache_entry(ce, force_mode)chmod_index_entry(&the_index, (ce), (force_mode)) < 0)
44 fprintf(stderr__stderrp, "cannot chmod '%s'", ce->name);
45 }
46}
47
48static int fix_unmerged_status(struct diff_filepair *p,
49 struct update_callback_data *data)
50{
51 if (p->status != DIFF_STATUS_UNMERGED'U')
52 return p->status;
53 if (!(data->flags & ADD_CACHE_IGNORE_REMOVAL8) && !p->two->mode)
54 /*
55 * This is not an explicit add request, and the
56 * path is missing from the working tree (deleted)
57 */
58 return DIFF_STATUS_DELETED'D';
59 else
60 /*
61 * Either an explicit add request, or path exists
62 * in the working tree. An attempt to explicitly
63 * add a path that does not exist in the working tree
64 * will be caught as an error by the caller immediately.
65 */
66 return DIFF_STATUS_MODIFIED'M';
67}
68
69static void update_callback(struct diff_queue_struct *q,
70 struct diff_options *opt, void *cbdata)
71{
72 int i;
73 struct update_callback_data *data = cbdata;
74
75 for (i = 0; i < q->nr; i++) {
76 struct diff_filepair *p = q->queue[i];
77 const char *path = p->one->path;
78 switch (fix_unmerged_status(p, data)) {
79 default:
80 die(_("unexpected diff status %c"), p->status);
81 case DIFF_STATUS_MODIFIED'M':
82 case DIFF_STATUS_TYPE_CHANGED'T':
83 if (add_file_to_index(&the_index, path, data->flags)) {
84 if (!(data->flags & ADD_CACHE_IGNORE_ERRORS4))
85 die(_("updating files failed"));
86 data->add_errors++;
87 }
88 break;
89 case DIFF_STATUS_DELETED'D':
90 if (data->flags & ADD_CACHE_IGNORE_REMOVAL8)
91 break;
92 if (!(data->flags & ADD_CACHE_PRETEND2))
93 remove_file_from_index(&the_index, path);
94 if (data->flags & (ADD_CACHE_PRETEND2|ADD_CACHE_VERBOSE1))
95 printf(_("remove '%s'\n"), path);
96 break;
97 }
98 }
99}
100
101int add_files_to_cache(const char *prefix,
102 const struct pathspec *pathspec, int flags)
103{
104 struct update_callback_data data;
105 struct rev_info rev;
106
107 memset(&data, 0, sizeof(data))__builtin___memset_chk (&data, 0, sizeof(data), __builtin_object_size
(&data, 0));
108 data.flags = flags;
109
110 init_revisions(&rev, prefix);
111 setup_revisions(0, NULL((void*)0), &rev, NULL((void*)0));
112 if (pathspec)
113 copy_pathspec(&rev.prune_data, pathspec);
114 rev.diffopt.output_format = DIFF_FORMAT_CALLBACK0x1000;
115 rev.diffopt.format_callback = update_callback;
116 rev.diffopt.format_callback_data = &data;
117 rev.max_count = 0; /* do not compare unmerged paths with stage #2 */
118 run_diff_files(&rev, DIFF_RACY_IS_MODIFIED02);
119 return !!data.add_errors;
120}
121
122static char *prune_directory(struct dir_struct *dir, struct pathspec *pathspec, int prefix)
123{
124 char *seen;
125 int i;
126 struct dir_entry **src, **dst;
127
128 seen = xcalloc(pathspec->nr, 1);
129
130 src = dst = dir->entries;
131 i = dir->nr;
132 while (--i >= 0) {
133 struct dir_entry *entry = *src++;
134 if (dir_path_match(entry, pathspec, prefix, seen))
135 *dst++ = entry;
136 }
137 dir->nr = dst - dir->entries;
138 add_pathspec_matches_against_index(pathspec, seen);
139 return seen;
140}
141
142static void refresh(int verbose, const struct pathspec *pathspec)
143{
144 char *seen;
145 int i;
146
147 seen = xcalloc(pathspec->nr, 1);
148 refresh_index(&the_index, verbose ? REFRESH_IN_PORCELAIN0x0020 : REFRESH_QUIET0x0004,
149 pathspec, seen, _("Unstaged changes after refreshing the index:"));
150 for (i = 0; i < pathspec->nr; i++) {
151 if (!seen[i])
152 die(_("pathspec '%s' did not match any files"),
153 pathspec->items[i].match);
154 }
155 free(seen);
156}
157
158int run_add_interactive(const char *revision, const char *patch_mode,
159 const struct pathspec *pathspec)
160{
161 int status, i;
162 struct argv_array argv = ARGV_ARRAY_INIT{ empty_argv, 0, 0 };
163
164 argv_array_push(&argv, "add--interactive");
165 if (patch_mode)
166 argv_array_push(&argv, patch_mode);
167 if (revision)
168 argv_array_push(&argv, revision);
169 argv_array_push(&argv, "--");
170 for (i = 0; i < pathspec->nr; i++)
171 /* pass original pathspec, to be re-parsed */
172 argv_array_push(&argv, pathspec->items[i].original);
173
174 status = run_command_v_opt(argv.argv, RUN_GIT_CMD2);
175 argv_array_clear(&argv);
176 return status;
177}
178
179int interactive_add(int argc, const char **argv, const char *prefix, int patch)
180{
181 struct pathspec pathspec;
182
183 parse_pathspec(&pathspec, 0,
184 PATHSPEC_PREFER_FULL(1<<1) |
185 PATHSPEC_SYMLINK_LEADING_PATH(1<<4) |
186 PATHSPEC_PREFIX_ORIGIN(1<<6),
187 prefix, argv);
188
189 return run_add_interactive(NULL((void*)0),
190 patch ? "--patch" : NULL((void*)0),
191 &pathspec);
192}
193
194static int edit_patch(int argc, const char **argv, const char *prefix)
195{
196 char *file = git_pathdup("ADD_EDIT.patch");
197 const char *apply_argv[] = { "apply", "--recount", "--cached",
198 NULL((void*)0), NULL((void*)0) };
199 struct child_process child = CHILD_PROCESS_INIT{ ((void*)0), { empty_argv, 0, 0 }, { empty_argv, 0, 0 } };
200 struct rev_info rev;
201 int out;
202 struct stat st;
203
204 apply_argv[3] = file;
205
206 git_config(git_diff_basic_config, NULL((void*)0)); /* no "diff" UI options */
207
208 if (read_cache()read_index(&the_index) < 0)
209 die(_("Could not read the index"));
210
211 init_revisions(&rev, prefix);
212 rev.diffopt.context = 7;
213
214 argc = setup_revisions(argc, argv, &rev, NULL((void*)0));
Value stored to 'argc' is never read
215 rev.diffopt.output_format = DIFF_FORMAT_PATCH0x0010;
216 rev.diffopt.use_color = 0;
217 DIFF_OPT_SET(&rev.diffopt, IGNORE_DIRTY_SUBMODULES)(((&rev.diffopt)->flags |= (1 << 26)),((&rev
.diffopt)->touched_flags |= (1 << 26)));
218 out = open(file, O_CREAT0x0200 | O_WRONLY0x0001, 0666);
219 if (out < 0)
220 die(_("Could not open '%s' for writing."), file);
221 rev.diffopt.file = xfdopen(out, "w");
222 rev.diffopt.close_file = 1;
223 if (run_diff_files(&rev, 0))
224 die(_("Could not write patch"));
225
226 if (launch_editor(file, NULL((void*)0), NULL((void*)0)))
227 die(_("editing patch failed"));
228
229 if (stat(file, &st))
230 die_errno(_("Could not stat '%s'"), file);
231 if (!st.st_size)
232 die(_("Empty patch. Aborted."));
233
234 child.git_cmd = 1;
235 child.argv = apply_argv;
236 if (run_command(&child))
237 die(_("Could not apply '%s'"), file);
238
239 unlink(file);
240 free(file);
241 return 0;
242}
243
244static struct lock_file lock_file;
245
246static const char ignore_error[] =
247N_("The following paths are ignored by one of your .gitignore files:\n")("The following paths are ignored by one of your .gitignore files:\n"
);
248
249static int verbose, show_only, ignored_too, refresh_only;
250static int ignore_add_errors, intent_to_add, ignore_missing;
251
252#define ADDREMOVE_DEFAULT1 1
253static int addremove = ADDREMOVE_DEFAULT1;
254static int addremove_explicit = -1; /* unspecified */
255
256static char *chmod_arg;
257
258static int ignore_removal_cb(const struct option *opt, const char *arg, int unset)
259{
260 /* if we are told to ignore, we are not adding removals */
261 *(int *)opt->value = !unset ? 0 : 1;
262 return 0;
263}
264
265static struct option builtin_add_options[] = {
266 OPT__DRY_RUN(&show_only, N_("dry run")){ OPTION_SET_INT, ('n'), ("dry-run"), ((&show_only)), ((void
*)0), ((("dry run"))), PARSE_OPT_NOARG, ((void*)0), (1) },
267 OPT__VERBOSE(&verbose, N_("be verbose")){ OPTION_COUNTUP, ('v'), ("verbose"), ((&verbose)), ((void
*)0), ((("be verbose"))), PARSE_OPT_NOARG },
268 OPT_GROUP(""){ OPTION_GROUP, 0, ((void*)0), ((void*)0), ((void*)0), ("") },
269 OPT_BOOL('i', "interactive", &add_interactive, N_("interactive picking")){ OPTION_SET_INT, ('i'), ("interactive"), (&add_interactive
), ((void*)0), (("interactive picking")), PARSE_OPT_NOARG, ((
void*)0), (1) },
270 OPT_BOOL('p', "patch", &patch_interactive, N_("select hunks interactively")){ OPTION_SET_INT, ('p'), ("patch"), (&patch_interactive),
((void*)0), (("select hunks interactively")), PARSE_OPT_NOARG
, ((void*)0), (1) },
271 OPT_BOOL('e', "edit", &edit_interactive, N_("edit current diff and apply")){ OPTION_SET_INT, ('e'), ("edit"), (&edit_interactive), (
(void*)0), (("edit current diff and apply")), PARSE_OPT_NOARG
, ((void*)0), (1) },
272 OPT__FORCE(&ignored_too, N_("allow adding otherwise ignored files")){ OPTION_COUNTUP, ('f'), ("force"), ((&ignored_too)), ((void
*)0), ((("allow adding otherwise ignored files"))), PARSE_OPT_NOARG
},
273 OPT_BOOL('u', "update", &take_worktree_changes, N_("update tracked files")){ OPTION_SET_INT, ('u'), ("update"), (&take_worktree_changes
), ((void*)0), (("update tracked files")), PARSE_OPT_NOARG, (
(void*)0), (1) },
274 OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")){ OPTION_SET_INT, ('N'), ("intent-to-add"), (&intent_to_add
), ((void*)0), (("record only the fact that the path will be added later"
)), PARSE_OPT_NOARG, ((void*)0), (1) },
275 OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")){ OPTION_SET_INT, ('A'), ("all"), (&addremove_explicit), (
(void*)0), (("add changes from all tracked and untracked files"
)), PARSE_OPT_NOARG, ((void*)0), (1) },
276 { OPTION_CALLBACK, 0, "ignore-removal", &addremove_explicit,
277 NULL((void*)0) /* takes no arguments */,
278 N_("ignore paths removed in the working tree (same as --no-all)")("ignore paths removed in the working tree (same as --no-all)"
),
279 PARSE_OPT_NOARG, ignore_removal_cb },
280 OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")){ OPTION_SET_INT, (0), ("refresh"), (&refresh_only), ((void
*)0), (("don't add, only refresh the index")), PARSE_OPT_NOARG
, ((void*)0), (1) },
281 OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")){ OPTION_SET_INT, (0), ("ignore-errors"), (&ignore_add_errors
), ((void*)0), (("just skip files which cannot be added because of errors"
)), PARSE_OPT_NOARG, ((void*)0), (1) },
282 OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")){ OPTION_SET_INT, (0), ("ignore-missing"), (&ignore_missing
), ((void*)0), (("check if - even missing - files are ignored in dry run"
)), PARSE_OPT_NOARG, ((void*)0), (1) },
283 OPT_STRING( 0 , "chmod", &chmod_arg, N_("(+/-)x"), N_("override the executable bit of the listed files")){ OPTION_STRING, (0), ("chmod"), (&chmod_arg), (("(+/-)x"
)), (("override the executable bit of the listed files")) },
284 OPT_END(){ OPTION_END },
285};
286
287static int add_config(const char *var, const char *value, void *cb)
288{
289 if (!strcmp(var, "add.ignoreerrors") ||
290 !strcmp(var, "add.ignore-errors")) {
291 ignore_add_errors = git_config_bool(var, value);
292 return 0;
293 }
294 return git_default_config(var, value, cb);
295}
296
297static int add_files(struct dir_struct *dir, int flags)
298{
299 int i, exit_status = 0;
300
301 if (dir->ignored_nr) {
302 fprintf(stderr__stderrp, _(ignore_error));
303 for (i = 0; i < dir->ignored_nr; i++)
304 fprintf(stderr__stderrp, "%s\n", dir->ignored[i]->name);
305 fprintf(stderr__stderrp, _("Use -f if you really want to add them.\n"));
306 exit_status = 1;
307 }
308
309 for (i = 0; i < dir->nr; i++)
310 if (add_file_to_index(&the_index, dir->entries[i]->name, flags)) {
311 if (!ignore_add_errors)
312 die(_("adding files failed"));
313 exit_status = 1;
314 }
315 return exit_status;
316}
317
318int cmd_add(int argc, const char **argv, const char *prefix)
319{
320 int exit_status = 0;
321 struct pathspec pathspec;
322 struct dir_struct dir;
323 int flags;
324 int add_new_files;
325 int require_pathspec;
326 char *seen = NULL((void*)0);
327
328 git_config(add_config, NULL((void*)0));
329
330 argc = parse_options(argc, argv, prefix, builtin_add_options,
331 builtin_add_usage, PARSE_OPT_KEEP_ARGV0);
332 if (patch_interactive)
333 add_interactive = 1;
334 if (add_interactive)
335 exit(interactive_add(argc - 1, argv + 1, prefix, patch_interactive));
336
337 if (edit_interactive)
338 return(edit_patch(argc, argv, prefix));
339 argc--;
340 argv++;
341
342 if (0 <= addremove_explicit)
343 addremove = addremove_explicit;
344 else if (take_worktree_changes && ADDREMOVE_DEFAULT1)
345 addremove = 0; /* "-u" was given but not "-A" */
346
347 if (addremove && take_worktree_changes)
348 die(_("-A and -u are mutually incompatible"));
349
350 if (!take_worktree_changes && addremove_explicit < 0 && argc)
351 /* Turn "git add pathspec..." to "git add -A pathspec..." */
352 addremove = 1;
353
354 if (!show_only && ignore_missing)
355 die(_("Option --ignore-missing can only be used together with --dry-run"));
356
357 if (chmod_arg && ((chmod_arg[0] != '-' && chmod_arg[0] != '+') ||
358 chmod_arg[1] != 'x' || chmod_arg[2]))
359 die(_("--chmod param '%s' must be either -x or +x"), chmod_arg);
360
361 add_new_files = !take_worktree_changes && !refresh_only;
362 require_pathspec = !(take_worktree_changes || (0 < addremove_explicit));
363
364 hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR1);
365
366 flags = ((verbose ? ADD_CACHE_VERBOSE1 : 0) |
367 (show_only ? ADD_CACHE_PRETEND2 : 0) |
368 (intent_to_add ? ADD_CACHE_INTENT16 : 0) |
369 (ignore_add_errors ? ADD_CACHE_IGNORE_ERRORS4 : 0) |
370 (!(addremove || take_worktree_changes)
371 ? ADD_CACHE_IGNORE_REMOVAL8 : 0));
372
373 if (require_pathspec && argc == 0) {
374 fprintf(stderr__stderrp, _("Nothing specified, nothing added.\n"));
375 fprintf(stderr__stderrp, _("Maybe you wanted to say 'git add .'?\n"));
376 return 0;
377 }
378
379 if (read_cache()read_index(&the_index) < 0)
380 die(_("index file corrupt"));
381
382 /*
383 * Check the "pathspec '%s' did not match any files" block
384 * below before enabling new magic.
385 */
386 parse_pathspec(&pathspec, 0,
387 PATHSPEC_PREFER_FULL(1<<1) |
388 PATHSPEC_SYMLINK_LEADING_PATH(1<<4) |
389 PATHSPEC_STRIP_SUBMODULE_SLASH_EXPENSIVE(1<<5),
390 prefix, argv);
391
392 if (add_new_files) {
393 int baselen;
394
395 /* Set up the default git porcelain excludes */
396 memset(&dir, 0, sizeof(dir))__builtin___memset_chk (&dir, 0, sizeof(dir), __builtin_object_size
(&dir, 0));
397 if (!ignored_too) {
398 dir.flags |= DIR_COLLECT_IGNORED;
399 setup_standard_excludes(&dir);
400 }
401
402 /* This picks up the paths that are not tracked */
403 baselen = fill_directory(&dir, &pathspec);
404 if (pathspec.nr)
405 seen = prune_directory(&dir, &pathspec, baselen);
406 }
407
408 if (refresh_only) {
409 refresh(verbose, &pathspec);
410 goto finish;
411 }
412
413 if (pathspec.nr) {
414 int i;
415
416 if (!seen)
417 seen = find_pathspecs_matching_against_index(&pathspec);
418
419 /*
420 * file_exists() assumes exact match
421 */
422 GUARD_PATHSPEC(&pathspec,do { if ((&pathspec)->magic & ~((1<<0) | (1<<
2) | (1<<3) | (1<<4) | (1<<5))) die("BUG:%s:%d: unsupported magic %x"
, "builtin/add.c", 427, (&pathspec)->magic & ~((1<<
0) | (1<<2) | (1<<3) | (1<<4) | (1<<5
))); } while (0)
423 PATHSPEC_FROMTOP |do { if ((&pathspec)->magic & ~((1<<0) | (1<<
2) | (1<<3) | (1<<4) | (1<<5))) die("BUG:%s:%d: unsupported magic %x"
, "builtin/add.c", 427, (&pathspec)->magic & ~((1<<
0) | (1<<2) | (1<<3) | (1<<4) | (1<<5
))); } while (0)
424 PATHSPEC_LITERAL |do { if ((&pathspec)->magic & ~((1<<0) | (1<<
2) | (1<<3) | (1<<4) | (1<<5))) die("BUG:%s:%d: unsupported magic %x"
, "builtin/add.c", 427, (&pathspec)->magic & ~((1<<
0) | (1<<2) | (1<<3) | (1<<4) | (1<<5
))); } while (0)
425 PATHSPEC_GLOB |do { if ((&pathspec)->magic & ~((1<<0) | (1<<
2) | (1<<3) | (1<<4) | (1<<5))) die("BUG:%s:%d: unsupported magic %x"
, "builtin/add.c", 427, (&pathspec)->magic & ~((1<<
0) | (1<<2) | (1<<3) | (1<<4) | (1<<5
))); } while (0)
426 PATHSPEC_ICASE |do { if ((&pathspec)->magic & ~((1<<0) | (1<<
2) | (1<<3) | (1<<4) | (1<<5))) die("BUG:%s:%d: unsupported magic %x"
, "builtin/add.c", 427, (&pathspec)->magic & ~((1<<
0) | (1<<2) | (1<<3) | (1<<4) | (1<<5
))); } while (0)
427 PATHSPEC_EXCLUDE)do { if ((&pathspec)->magic & ~((1<<0) | (1<<
2) | (1<<3) | (1<<4) | (1<<5))) die("BUG:%s:%d: unsupported magic %x"
, "builtin/add.c", 427, (&pathspec)->magic & ~((1<<
0) | (1<<2) | (1<<3) | (1<<4) | (1<<5
))); } while (0);
428
429 for (i = 0; i < pathspec.nr; i++) {
430 const char *path = pathspec.items[i].match;
431 if (pathspec.items[i].magic & PATHSPEC_EXCLUDE(1<<5))
432 continue;
433 if (!seen[i] && path[0] &&
434 ((pathspec.items[i].magic &
435 (PATHSPEC_GLOB(1<<3) | PATHSPEC_ICASE(1<<4))) ||
436 !file_exists(path))) {
437 if (ignore_missing) {
438 int dtype = DT_UNKNOWN0;
439 if (is_excluded(&dir, path, &dtype))
440 dir_add_ignored(&dir, path, pathspec.items[i].len);
441 } else
442 die(_("pathspec '%s' did not match any files"),
443 pathspec.items[i].original);
444 }
445 }
446 free(seen);
447 }
448
449 plug_bulk_checkin();
450
451 exit_status |= add_files_to_cache(prefix, &pathspec, flags);
452
453 if (add_new_files)
454 exit_status |= add_files(&dir, flags);
455
456 if (chmod_arg && pathspec.nr)
457 chmod_pathspec(&pathspec, chmod_arg[0]);
458 unplug_bulk_checkin();
459
460finish:
461 if (active_cache_changed(the_index.cache_changed)) {
462 if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK(1 << 0)))
463 die(_("Unable to write new index file"));
464 }
465
466 return exit_status;
467}