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