Merge branch 'maint-1.7.0' into maint-1.7.1
[git] / builtin / ls-files.c
1 /*
2  * This merges the file listing in the directory cache index
3  * with the actual working directory list, and shows different
4  * combinations of the two.
5  *
6  * Copyright (C) Linus Torvalds, 2005
7  */
8 #include "cache.h"
9 #include "quote.h"
10 #include "dir.h"
11 #include "builtin.h"
12 #include "tree.h"
13 #include "parse-options.h"
14 #include "resolve-undo.h"
15 #include "string-list.h"
16
17 static int abbrev;
18 static int show_deleted;
19 static int show_cached;
20 static int show_others;
21 static int show_stage;
22 static int show_unmerged;
23 static int show_resolve_undo;
24 static int show_modified;
25 static int show_killed;
26 static int show_valid_bit;
27 static int line_terminator = '\n';
28
29 static const char *prefix;
30 static int max_prefix_len;
31 static int prefix_len;
32 static const char **pathspec;
33 static int error_unmatch;
34 static char *ps_matched;
35 static const char *with_tree;
36 static int exc_given;
37
38 static const char *tag_cached = "";
39 static const char *tag_unmerged = "";
40 static const char *tag_removed = "";
41 static const char *tag_other = "";
42 static const char *tag_killed = "";
43 static const char *tag_modified = "";
44 static const char *tag_skip_worktree = "";
45 static const char *tag_resolve_undo = "";
46
47 static void write_name(const char* name, size_t len)
48 {
49         write_name_quoted_relative(name, len, prefix, prefix_len, stdout,
50                         line_terminator);
51 }
52
53 static void show_dir_entry(const char *tag, struct dir_entry *ent)
54 {
55         int len = max_prefix_len;
56
57         if (len >= ent->len)
58                 die("git ls-files: internal error - directory entry not superset of prefix");
59
60         if (!match_pathspec(pathspec, ent->name, ent->len, len, ps_matched))
61                 return;
62
63         fputs(tag, stdout);
64         write_name(ent->name, ent->len);
65 }
66
67 static void show_other_files(struct dir_struct *dir)
68 {
69         int i;
70
71         for (i = 0; i < dir->nr; i++) {
72                 struct dir_entry *ent = dir->entries[i];
73                 if (!cache_name_is_other(ent->name, ent->len))
74                         continue;
75                 show_dir_entry(tag_other, ent);
76         }
77 }
78
79 static void show_killed_files(struct dir_struct *dir)
80 {
81         int i;
82         for (i = 0; i < dir->nr; i++) {
83                 struct dir_entry *ent = dir->entries[i];
84                 char *cp, *sp;
85                 int pos, len, killed = 0;
86
87                 for (cp = ent->name; cp - ent->name < ent->len; cp = sp + 1) {
88                         sp = strchr(cp, '/');
89                         if (!sp) {
90                                 /* If ent->name is prefix of an entry in the
91                                  * cache, it will be killed.
92                                  */
93                                 pos = cache_name_pos(ent->name, ent->len);
94                                 if (0 <= pos)
95                                         die("bug in show-killed-files");
96                                 pos = -pos - 1;
97                                 while (pos < active_nr &&
98                                        ce_stage(active_cache[pos]))
99                                         pos++; /* skip unmerged */
100                                 if (active_nr <= pos)
101                                         break;
102                                 /* pos points at a name immediately after
103                                  * ent->name in the cache.  Does it expect
104                                  * ent->name to be a directory?
105                                  */
106                                 len = ce_namelen(active_cache[pos]);
107                                 if ((ent->len < len) &&
108                                     !strncmp(active_cache[pos]->name,
109                                              ent->name, ent->len) &&
110                                     active_cache[pos]->name[ent->len] == '/')
111                                         killed = 1;
112                                 break;
113                         }
114                         if (0 <= cache_name_pos(ent->name, sp - ent->name)) {
115                                 /* If any of the leading directories in
116                                  * ent->name is registered in the cache,
117                                  * ent->name will be killed.
118                                  */
119                                 killed = 1;
120                                 break;
121                         }
122                 }
123                 if (killed)
124                         show_dir_entry(tag_killed, dir->entries[i]);
125         }
126 }
127
128 static void show_ce_entry(const char *tag, struct cache_entry *ce)
129 {
130         int len = max_prefix_len;
131
132         if (len >= ce_namelen(ce))
133                 die("git ls-files: internal error - cache entry not superset of prefix");
134
135         if (!match_pathspec(pathspec, ce->name, ce_namelen(ce), len, ps_matched))
136                 return;
137
138         if (tag && *tag && show_valid_bit &&
139             (ce->ce_flags & CE_VALID)) {
140                 static char alttag[4];
141                 memcpy(alttag, tag, 3);
142                 if (isalpha(tag[0]))
143                         alttag[0] = tolower(tag[0]);
144                 else if (tag[0] == '?')
145                         alttag[0] = '!';
146                 else {
147                         alttag[0] = 'v';
148                         alttag[1] = tag[0];
149                         alttag[2] = ' ';
150                         alttag[3] = 0;
151                 }
152                 tag = alttag;
153         }
154
155         if (!show_stage) {
156                 fputs(tag, stdout);
157         } else {
158                 printf("%s%06o %s %d\t",
159                        tag,
160                        ce->ce_mode,
161                        find_unique_abbrev(ce->sha1,abbrev),
162                        ce_stage(ce));
163         }
164         write_name(ce->name, ce_namelen(ce));
165 }
166
167 static int show_one_ru(struct string_list_item *item, void *cbdata)
168 {
169         const char *path = item->string;
170         struct resolve_undo_info *ui = item->util;
171         int i, len;
172
173         len = strlen(path);
174         if (len < max_prefix_len)
175                 return 0; /* outside of the prefix */
176         if (!match_pathspec(pathspec, path, len, max_prefix_len, ps_matched))
177                 return 0; /* uninterested */
178         for (i = 0; i < 3; i++) {
179                 if (!ui->mode[i])
180                         continue;
181                 printf("%s%06o %s %d\t", tag_resolve_undo, ui->mode[i],
182                        find_unique_abbrev(ui->sha1[i], abbrev),
183                        i + 1);
184                 write_name(path, len);
185         }
186         return 0;
187 }
188
189 static void show_ru_info(void)
190 {
191         if (!the_index.resolve_undo)
192                 return;
193         for_each_string_list(show_one_ru, the_index.resolve_undo, NULL);
194 }
195
196 static void show_files(struct dir_struct *dir)
197 {
198         int i;
199
200         /* For cached/deleted files we don't need to even do the readdir */
201         if (show_others || show_killed) {
202                 fill_directory(dir, pathspec);
203                 if (show_others)
204                         show_other_files(dir);
205                 if (show_killed)
206                         show_killed_files(dir);
207         }
208         if (show_cached | show_stage) {
209                 for (i = 0; i < active_nr; i++) {
210                         struct cache_entry *ce = active_cache[i];
211                         int dtype = ce_to_dtype(ce);
212                         if (dir->flags & DIR_SHOW_IGNORED &&
213                             !excluded(dir, ce->name, &dtype))
214                                 continue;
215                         if (show_unmerged && !ce_stage(ce))
216                                 continue;
217                         if (ce->ce_flags & CE_UPDATE)
218                                 continue;
219                         show_ce_entry(ce_stage(ce) ? tag_unmerged :
220                                 (ce_skip_worktree(ce) ? tag_skip_worktree : tag_cached), ce);
221                 }
222         }
223         if (show_deleted | show_modified) {
224                 for (i = 0; i < active_nr; i++) {
225                         struct cache_entry *ce = active_cache[i];
226                         struct stat st;
227                         int err;
228                         int dtype = ce_to_dtype(ce);
229                         if (dir->flags & DIR_SHOW_IGNORED &&
230                             !excluded(dir, ce->name, &dtype))
231                                 continue;
232                         if (ce->ce_flags & CE_UPDATE)
233                                 continue;
234                         if (ce_skip_worktree(ce))
235                                 continue;
236                         err = lstat(ce->name, &st);
237                         if (show_deleted && err)
238                                 show_ce_entry(tag_removed, ce);
239                         if (show_modified && ce_modified(ce, &st, 0))
240                                 show_ce_entry(tag_modified, ce);
241                 }
242         }
243 }
244
245 /*
246  * Prune the index to only contain stuff starting with "prefix"
247  */
248 static void prune_cache(const char *prefix)
249 {
250         int pos = cache_name_pos(prefix, max_prefix_len);
251         unsigned int first, last;
252
253         if (pos < 0)
254                 pos = -pos-1;
255         memmove(active_cache, active_cache + pos,
256                 (active_nr - pos) * sizeof(struct cache_entry *));
257         active_nr -= pos;
258         first = 0;
259         last = active_nr;
260         while (last > first) {
261                 int next = (last + first) >> 1;
262                 struct cache_entry *ce = active_cache[next];
263                 if (!strncmp(ce->name, prefix, max_prefix_len)) {
264                         first = next+1;
265                         continue;
266                 }
267                 last = next;
268         }
269         active_nr = last;
270 }
271
272 static const char *pathspec_prefix(const char *prefix)
273 {
274         const char **p, *n, *prev;
275         unsigned long max;
276
277         if (!pathspec) {
278                 max_prefix_len = prefix ? strlen(prefix) : 0;
279                 return prefix;
280         }
281
282         prev = NULL;
283         max = PATH_MAX;
284         for (p = pathspec; (n = *p) != NULL; p++) {
285                 int i, len = 0;
286                 for (i = 0; i < max; i++) {
287                         char c = n[i];
288                         if (prev && prev[i] != c)
289                                 break;
290                         if (!c || c == '*' || c == '?')
291                                 break;
292                         if (c == '/')
293                                 len = i+1;
294                 }
295                 prev = n;
296                 if (len < max) {
297                         max = len;
298                         if (!max)
299                                 break;
300                 }
301         }
302
303         max_prefix_len = max;
304         return max ? xmemdupz(prev, max) : NULL;
305 }
306
307 static void strip_trailing_slash_from_submodules(void)
308 {
309         const char **p;
310
311         for (p = pathspec; *p != NULL; p++) {
312                 int len = strlen(*p), pos;
313
314                 if (len < 1 || (*p)[len - 1] != '/')
315                         continue;
316                 pos = cache_name_pos(*p, len - 1);
317                 if (pos >= 0 && S_ISGITLINK(active_cache[pos]->ce_mode))
318                         *p = xstrndup(*p, len - 1);
319         }
320 }
321
322 /*
323  * Read the tree specified with --with-tree option
324  * (typically, HEAD) into stage #1 and then
325  * squash them down to stage #0.  This is used for
326  * --error-unmatch to list and check the path patterns
327  * that were given from the command line.  We are not
328  * going to write this index out.
329  */
330 void overlay_tree_on_cache(const char *tree_name, const char *prefix)
331 {
332         struct tree *tree;
333         unsigned char sha1[20];
334         const char **match;
335         struct cache_entry *last_stage0 = NULL;
336         int i;
337
338         if (get_sha1(tree_name, sha1))
339                 die("tree-ish %s not found.", tree_name);
340         tree = parse_tree_indirect(sha1);
341         if (!tree)
342                 die("bad tree-ish %s", tree_name);
343
344         /* Hoist the unmerged entries up to stage #3 to make room */
345         for (i = 0; i < active_nr; i++) {
346                 struct cache_entry *ce = active_cache[i];
347                 if (!ce_stage(ce))
348                         continue;
349                 ce->ce_flags |= CE_STAGEMASK;
350         }
351
352         if (prefix) {
353                 static const char *(matchbuf[2]);
354                 matchbuf[0] = prefix;
355                 matchbuf[1] = NULL;
356                 match = matchbuf;
357         } else
358                 match = NULL;
359         if (read_tree(tree, 1, match))
360                 die("unable to read tree entries %s", tree_name);
361
362         for (i = 0; i < active_nr; i++) {
363                 struct cache_entry *ce = active_cache[i];
364                 switch (ce_stage(ce)) {
365                 case 0:
366                         last_stage0 = ce;
367                         /* fallthru */
368                 default:
369                         continue;
370                 case 1:
371                         /*
372                          * If there is stage #0 entry for this, we do not
373                          * need to show it.  We use CE_UPDATE bit to mark
374                          * such an entry.
375                          */
376                         if (last_stage0 &&
377                             !strcmp(last_stage0->name, ce->name))
378                                 ce->ce_flags |= CE_UPDATE;
379                 }
380         }
381 }
382
383 int report_path_error(const char *ps_matched, const char **pathspec, int prefix_len)
384 {
385         /*
386          * Make sure all pathspec matched; otherwise it is an error.
387          */
388         int num, errors = 0;
389         for (num = 0; pathspec[num]; num++) {
390                 int other, found_dup;
391
392                 if (ps_matched[num])
393                         continue;
394                 /*
395                  * The caller might have fed identical pathspec
396                  * twice.  Do not barf on such a mistake.
397                  */
398                 for (found_dup = other = 0;
399                      !found_dup && pathspec[other];
400                      other++) {
401                         if (other == num || !ps_matched[other])
402                                 continue;
403                         if (!strcmp(pathspec[other], pathspec[num]))
404                                 /*
405                                  * Ok, we have a match already.
406                                  */
407                                 found_dup = 1;
408                 }
409                 if (found_dup)
410                         continue;
411
412                 error("pathspec '%s' did not match any file(s) known to git.",
413                       pathspec[num] + prefix_len);
414                 errors++;
415         }
416         return errors;
417 }
418
419 static const char * const ls_files_usage[] = {
420         "git ls-files [options] [<file>]*",
421         NULL
422 };
423
424 static int option_parse_z(const struct option *opt,
425                           const char *arg, int unset)
426 {
427         line_terminator = unset ? '\n' : '\0';
428
429         return 0;
430 }
431
432 static int option_parse_exclude(const struct option *opt,
433                                 const char *arg, int unset)
434 {
435         struct exclude_list *list = opt->value;
436
437         exc_given = 1;
438         add_exclude(arg, "", 0, list);
439
440         return 0;
441 }
442
443 static int option_parse_exclude_from(const struct option *opt,
444                                      const char *arg, int unset)
445 {
446         struct dir_struct *dir = opt->value;
447
448         exc_given = 1;
449         add_excludes_from_file(dir, arg);
450
451         return 0;
452 }
453
454 static int option_parse_exclude_standard(const struct option *opt,
455                                          const char *arg, int unset)
456 {
457         struct dir_struct *dir = opt->value;
458
459         exc_given = 1;
460         setup_standard_excludes(dir);
461
462         return 0;
463 }
464
465 int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
466 {
467         int require_work_tree = 0, show_tag = 0;
468         const char *max_prefix;
469         struct dir_struct dir;
470         struct option builtin_ls_files_options[] = {
471                 { OPTION_CALLBACK, 'z', NULL, NULL, NULL,
472                         "paths are separated with NUL character",
473                         PARSE_OPT_NOARG, option_parse_z },
474                 OPT_BOOLEAN('t', NULL, &show_tag,
475                         "identify the file status with tags"),
476                 OPT_BOOLEAN('v', NULL, &show_valid_bit,
477                         "use lowercase letters for 'assume unchanged' files"),
478                 OPT_BOOLEAN('c', "cached", &show_cached,
479                         "show cached files in the output (default)"),
480                 OPT_BOOLEAN('d', "deleted", &show_deleted,
481                         "show deleted files in the output"),
482                 OPT_BOOLEAN('m', "modified", &show_modified,
483                         "show modified files in the output"),
484                 OPT_BOOLEAN('o', "others", &show_others,
485                         "show other files in the output"),
486                 OPT_BIT('i', "ignored", &dir.flags,
487                         "show ignored files in the output",
488                         DIR_SHOW_IGNORED),
489                 OPT_BOOLEAN('s', "stage", &show_stage,
490                         "show staged contents' object name in the output"),
491                 OPT_BOOLEAN('k', "killed", &show_killed,
492                         "show files on the filesystem that need to be removed"),
493                 OPT_BIT(0, "directory", &dir.flags,
494                         "show 'other' directories' name only",
495                         DIR_SHOW_OTHER_DIRECTORIES),
496                 OPT_NEGBIT(0, "empty-directory", &dir.flags,
497                         "don't show empty directories",
498                         DIR_HIDE_EMPTY_DIRECTORIES),
499                 OPT_BOOLEAN('u', "unmerged", &show_unmerged,
500                         "show unmerged files in the output"),
501                 OPT_BOOLEAN(0, "resolve-undo", &show_resolve_undo,
502                             "show resolve-undo information"),
503                 { OPTION_CALLBACK, 'x', "exclude", &dir.exclude_list[EXC_CMDL], "pattern",
504                         "skip files matching pattern",
505                         0, option_parse_exclude },
506                 { OPTION_CALLBACK, 'X', "exclude-from", &dir, "file",
507                         "exclude patterns are read from <file>",
508                         0, option_parse_exclude_from },
509                 OPT_STRING(0, "exclude-per-directory", &dir.exclude_per_dir, "file",
510                         "read additional per-directory exclude patterns in <file>"),
511                 { OPTION_CALLBACK, 0, "exclude-standard", &dir, NULL,
512                         "add the standard git exclusions",
513                         PARSE_OPT_NOARG, option_parse_exclude_standard },
514                 { OPTION_SET_INT, 0, "full-name", &prefix_len, NULL,
515                         "make the output relative to the project top directory",
516                         PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL },
517                 OPT_BOOLEAN(0, "error-unmatch", &error_unmatch,
518                         "if any <file> is not in the index, treat this as an error"),
519                 OPT_STRING(0, "with-tree", &with_tree, "tree-ish",
520                         "pretend that paths removed since <tree-ish> are still present"),
521                 OPT__ABBREV(&abbrev),
522                 OPT_END()
523         };
524
525         memset(&dir, 0, sizeof(dir));
526         prefix = cmd_prefix;
527         if (prefix)
528                 prefix_len = strlen(prefix);
529         git_config(git_default_config, NULL);
530
531         if (read_cache() < 0)
532                 die("index file corrupt");
533
534         argc = parse_options(argc, argv, prefix, builtin_ls_files_options,
535                         ls_files_usage, 0);
536         if (show_tag || show_valid_bit) {
537                 tag_cached = "H ";
538                 tag_unmerged = "M ";
539                 tag_removed = "R ";
540                 tag_modified = "C ";
541                 tag_other = "? ";
542                 tag_killed = "K ";
543                 tag_skip_worktree = "S ";
544                 tag_resolve_undo = "U ";
545         }
546         if (show_modified || show_others || show_deleted || (dir.flags & DIR_SHOW_IGNORED) || show_killed)
547                 require_work_tree = 1;
548         if (show_unmerged)
549                 /*
550                  * There's no point in showing unmerged unless
551                  * you also show the stage information.
552                  */
553                 show_stage = 1;
554         if (dir.exclude_per_dir)
555                 exc_given = 1;
556
557         if (require_work_tree && !is_inside_work_tree())
558                 setup_work_tree();
559
560         pathspec = get_pathspec(prefix, argv);
561
562         /* be nice with submodule paths ending in a slash */
563         if (pathspec)
564                 strip_trailing_slash_from_submodules();
565
566         /* Find common prefix for all pathspec's */
567         max_prefix = pathspec_prefix(prefix);
568
569         /* Treat unmatching pathspec elements as errors */
570         if (pathspec && error_unmatch) {
571                 int num;
572                 for (num = 0; pathspec[num]; num++)
573                         ;
574                 ps_matched = xcalloc(1, num);
575         }
576
577         if ((dir.flags & DIR_SHOW_IGNORED) && !exc_given)
578                 die("ls-files --ignored needs some exclude pattern");
579
580         /* With no flags, we default to showing the cached files */
581         if (!(show_stage | show_deleted | show_others | show_unmerged |
582               show_killed | show_modified | show_resolve_undo))
583                 show_cached = 1;
584
585         if (max_prefix)
586                 prune_cache(max_prefix);
587         if (with_tree) {
588                 /*
589                  * Basic sanity check; show-stages and show-unmerged
590                  * would not make any sense with this option.
591                  */
592                 if (show_stage || show_unmerged)
593                         die("ls-files --with-tree is incompatible with -s or -u");
594                 overlay_tree_on_cache(with_tree, max_prefix);
595         }
596         show_files(&dir);
597         if (show_resolve_undo)
598                 show_ru_info();
599
600         if (ps_matched) {
601                 int bad;
602                 bad = report_path_error(ps_matched, pathspec, prefix_len);
603                 if (bad)
604                         fprintf(stderr, "Did you forget to 'git add'?\n");
605
606                 return bad ? 1 : 0;
607         }
608
609         return 0;
610 }