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.
6 * Copyright (C) Linus Torvalds, 2005
14 static int show_deleted
= 0;
15 static int show_cached
= 0;
16 static int show_others
= 0;
17 static int show_ignored
= 0;
18 static int show_stage
= 0;
19 static int show_unmerged
= 0;
20 static int show_modified
= 0;
21 static int show_killed
= 0;
22 static int show_other_directories
= 0;
23 static int hide_empty_directories
= 0;
24 static int show_valid_bit
= 0;
25 static int line_terminator
= '\n';
27 static int prefix_len
= 0, prefix_offset
= 0;
28 static const char *prefix
= NULL
;
29 static const char **pathspec
= NULL
;
30 static int error_unmatch
= 0;
31 static char *ps_matched
= NULL
;
33 static const char *tag_cached
= "";
34 static const char *tag_unmerged
= "";
35 static const char *tag_removed
= "";
36 static const char *tag_other
= "";
37 static const char *tag_killed
= "";
38 static const char *tag_modified
= "";
40 static const char *exclude_per_dir
= NULL
;
42 /* We maintain three exclude pattern lists:
43 * EXC_CMDL lists patterns explicitly given on the command line.
44 * EXC_DIRS lists patterns obtained from per-directory ignore files.
45 * EXC_FILE lists patterns from fallback ignore files.
50 static struct exclude_list
{
60 static void add_exclude(const char *string
, const char *base
,
61 int baselen
, struct exclude_list
*which
)
63 struct exclude
*x
= xmalloc(sizeof (*x
));
68 if (which
->nr
== which
->alloc
) {
69 which
->alloc
= alloc_nr(which
->alloc
);
70 which
->excludes
= realloc(which
->excludes
,
71 which
->alloc
* sizeof(x
));
73 which
->excludes
[which
->nr
++] = x
;
76 static int add_excludes_from_file_1(const char *fname
,
79 struct exclude_list
*which
)
85 fd
= open(fname
, O_RDONLY
);
88 size
= lseek(fd
, 0, SEEK_END
);
91 lseek(fd
, 0, SEEK_SET
);
96 buf
= xmalloc(size
+1);
97 if (read(fd
, buf
, size
) != size
)
103 for (i
= 0; i
< size
; i
++) {
104 if (buf
[i
] == '\n') {
105 if (entry
!= buf
+ i
&& entry
[0] != '#') {
106 buf
[i
- (i
&& buf
[i
-1] == '\r')] = 0;
107 add_exclude(entry
, base
, baselen
, which
);
120 static void add_excludes_from_file(const char *fname
)
122 if (add_excludes_from_file_1(fname
, "", 0,
123 &exclude_list
[EXC_FILE
]) < 0)
124 die("cannot use %s as an exclude file", fname
);
127 static int push_exclude_per_directory(const char *base
, int baselen
)
129 char exclude_file
[PATH_MAX
];
130 struct exclude_list
*el
= &exclude_list
[EXC_DIRS
];
131 int current_nr
= el
->nr
;
133 if (exclude_per_dir
) {
134 memcpy(exclude_file
, base
, baselen
);
135 strcpy(exclude_file
+ baselen
, exclude_per_dir
);
136 add_excludes_from_file_1(exclude_file
, base
, baselen
, el
);
141 static void pop_exclude_per_directory(int stk
)
143 struct exclude_list
*el
= &exclude_list
[EXC_DIRS
];
146 free(el
->excludes
[--el
->nr
]);
149 /* Scan the list and let the last match determines the fate.
150 * Return 1 for exclude, 0 for include and -1 for undecided.
152 static int excluded_1(const char *pathname
,
154 struct exclude_list
*el
)
159 for (i
= el
->nr
- 1; 0 <= i
; i
--) {
160 struct exclude
*x
= el
->excludes
[i
];
161 const char *exclude
= x
->pattern
;
164 if (*exclude
== '!') {
169 if (!strchr(exclude
, '/')) {
171 const char *basename
= strrchr(pathname
, '/');
172 basename
= (basename
) ? basename
+1 : pathname
;
173 if (fnmatch(exclude
, basename
, 0) == 0)
177 /* match with FNM_PATHNAME:
178 * exclude has base (baselen long) implicitly
181 int baselen
= x
->baselen
;
185 if (pathlen
< baselen
||
186 (baselen
&& pathname
[baselen
-1] != '/') ||
187 strncmp(pathname
, x
->base
, baselen
))
190 if (fnmatch(exclude
, pathname
+baselen
,
196 return -1; /* undecided */
199 static int excluded(const char *pathname
)
201 int pathlen
= strlen(pathname
);
204 for (st
= EXC_CMDL
; st
<= EXC_FILE
; st
++) {
205 switch (excluded_1(pathname
, pathlen
, &exclude_list
[st
])) {
217 char name
[FLEX_ARRAY
]; /* more */
220 static struct nond_on_fs
**dir
;
222 static int dir_alloc
;
224 static void add_name(const char *pathname
, int len
)
226 struct nond_on_fs
*ent
;
228 if (cache_name_pos(pathname
, len
) >= 0)
231 if (nr_dir
== dir_alloc
) {
232 dir_alloc
= alloc_nr(dir_alloc
);
233 dir
= xrealloc(dir
, dir_alloc
*sizeof(ent
));
235 ent
= xmalloc(sizeof(*ent
) + len
+ 1);
237 memcpy(ent
->name
, pathname
, len
);
242 static int dir_exists(const char *dirname
, int len
)
244 int pos
= cache_name_pos(dirname
, len
);
248 if (pos
>= active_nr
) /* can't */
250 return !strncmp(active_cache
[pos
]->name
, dirname
, len
);
254 * Read a directory tree. We currently ignore anything but
255 * directories, regular files and symlinks. That's because git
256 * doesn't handle them at all yet. Maybe that will change some
259 * Also, we ignore the name ".git" (even if it is not a directory).
260 * That likely will not change.
262 static int read_directory(const char *path
, const char *base
, int baselen
)
264 DIR *fdir
= opendir(path
);
270 char fullname
[MAXPATHLEN
+ 1];
271 memcpy(fullname
, base
, baselen
);
273 exclude_stk
= push_exclude_per_directory(base
, baselen
);
275 while ((de
= readdir(fdir
)) != NULL
) {
278 if ((de
->d_name
[0] == '.') &&
279 (de
->d_name
[1] == 0 ||
280 !strcmp(de
->d_name
+ 1, ".") ||
281 !strcmp(de
->d_name
+ 1, "git")))
283 len
= strlen(de
->d_name
);
284 memcpy(fullname
+ baselen
, de
->d_name
, len
+1);
285 if (excluded(fullname
) != show_ignored
) {
286 if (!show_ignored
|| DTYPE(de
) != DT_DIR
) {
293 int subdir
, rewind_base
;
297 if (lstat(fullname
, &st
))
299 if (S_ISREG(st
.st_mode
) || S_ISLNK(st
.st_mode
))
301 if (!S_ISDIR(st
.st_mode
))
305 memcpy(fullname
+ baselen
+ len
, "/", 2);
307 rewind_base
= nr_dir
;
308 subdir
= read_directory(fullname
, fullname
,
310 if (show_other_directories
&&
311 (subdir
|| !hide_empty_directories
) &&
312 !dir_exists(fullname
, baselen
+ len
)) {
313 // Rewind the read subdirectory
314 while (nr_dir
> rewind_base
)
324 add_name(fullname
, baselen
+ len
);
329 pop_exclude_per_directory(exclude_stk
);
335 static int cmp_name(const void *p1
, const void *p2
)
337 const struct nond_on_fs
*e1
= *(const struct nond_on_fs
**)p1
;
338 const struct nond_on_fs
*e2
= *(const struct nond_on_fs
**)p2
;
340 return cache_name_compare(e1
->name
, e1
->len
,
345 * Match a pathspec against a filename. The first "len" characters
346 * are the common prefix
348 static int match(const char **spec
, char *ps_matched
,
349 const char *filename
, int len
)
353 while ((m
= *spec
++) != NULL
) {
354 int matchlen
= strlen(m
+ len
);
358 if (!strncmp(m
+ len
, filename
+ len
, matchlen
)) {
359 if (m
[len
+ matchlen
- 1] == '/')
361 switch (filename
[len
+ matchlen
]) {
366 if (!fnmatch(m
+ len
, filename
+ len
, 0))
379 static void show_dir_entry(const char *tag
, struct nond_on_fs
*ent
)
381 int len
= prefix_len
;
382 int offset
= prefix_offset
;
385 die("git-ls-files: internal error - directory entry not superset of prefix");
387 if (pathspec
&& !match(pathspec
, ps_matched
, ent
->name
, len
))
391 write_name_quoted("", 0, ent
->name
+ offset
, line_terminator
, stdout
);
392 putchar(line_terminator
);
395 static void show_other_files(void)
398 for (i
= 0; i
< nr_dir
; i
++) {
399 /* We should not have a matching entry, but we
400 * may have an unmerged entry for this path.
402 struct nond_on_fs
*ent
= dir
[i
];
403 int pos
= cache_name_pos(ent
->name
, ent
->len
);
404 struct cache_entry
*ce
;
406 die("bug in show-other-files");
408 if (pos
< active_nr
) {
409 ce
= active_cache
[pos
];
410 if (ce_namelen(ce
) == ent
->len
&&
411 !memcmp(ce
->name
, ent
->name
, ent
->len
))
412 continue; /* Yup, this one exists unmerged */
414 show_dir_entry(tag_other
, ent
);
418 static void show_killed_files(void)
421 for (i
= 0; i
< nr_dir
; i
++) {
422 struct nond_on_fs
*ent
= dir
[i
];
424 int pos
, len
, killed
= 0;
426 for (cp
= ent
->name
; cp
- ent
->name
< ent
->len
; cp
= sp
+ 1) {
427 sp
= strchr(cp
, '/');
429 /* If ent->name is prefix of an entry in the
430 * cache, it will be killed.
432 pos
= cache_name_pos(ent
->name
, ent
->len
);
434 die("bug in show-killed-files");
436 while (pos
< active_nr
&&
437 ce_stage(active_cache
[pos
]))
438 pos
++; /* skip unmerged */
439 if (active_nr
<= pos
)
441 /* pos points at a name immediately after
442 * ent->name in the cache. Does it expect
443 * ent->name to be a directory?
445 len
= ce_namelen(active_cache
[pos
]);
446 if ((ent
->len
< len
) &&
447 !strncmp(active_cache
[pos
]->name
,
448 ent
->name
, ent
->len
) &&
449 active_cache
[pos
]->name
[ent
->len
] == '/')
453 if (0 <= cache_name_pos(ent
->name
, sp
- ent
->name
)) {
454 /* If any of the leading directories in
455 * ent->name is registered in the cache,
456 * ent->name will be killed.
463 show_dir_entry(tag_killed
, dir
[i
]);
467 static void show_ce_entry(const char *tag
, struct cache_entry
*ce
)
469 int len
= prefix_len
;
470 int offset
= prefix_offset
;
472 if (len
>= ce_namelen(ce
))
473 die("git-ls-files: internal error - cache entry not superset of prefix");
475 if (pathspec
&& !match(pathspec
, ps_matched
, ce
->name
, len
))
478 if (tag
&& *tag
&& show_valid_bit
&&
479 (ce
->ce_flags
& htons(CE_VALID
))) {
480 static char alttag
[4];
481 memcpy(alttag
, tag
, 3);
483 alttag
[0] = tolower(tag
[0]);
484 else if (tag
[0] == '?')
497 write_name_quoted("", 0, ce
->name
+ offset
,
498 line_terminator
, stdout
);
499 putchar(line_terminator
);
502 printf("%s%06o %s %d\t",
505 sha1_to_hex(ce
->sha1
),
507 write_name_quoted("", 0, ce
->name
+ offset
,
508 line_terminator
, stdout
);
509 putchar(line_terminator
);
513 static void show_files(void)
517 /* For cached/deleted files we don't need to even do the readdir */
518 if (show_others
|| show_killed
) {
519 const char *path
= ".", *base
= "";
520 int baselen
= prefix_len
;
523 path
= base
= prefix
;
524 if (exclude_per_dir
) {
525 char *p
, *pp
= xmalloc(baselen
+1);
526 memcpy(pp
, prefix
, baselen
+1);
531 push_exclude_per_directory(pp
, p
-pp
);
544 read_directory(path
, base
, baselen
);
545 qsort(dir
, nr_dir
, sizeof(struct nond_on_fs
*), cmp_name
);
551 if (show_cached
| show_stage
) {
552 for (i
= 0; i
< active_nr
; i
++) {
553 struct cache_entry
*ce
= active_cache
[i
];
554 if (excluded(ce
->name
) != show_ignored
)
556 if (show_unmerged
&& !ce_stage(ce
))
558 show_ce_entry(ce_stage(ce
) ? tag_unmerged
: tag_cached
, ce
);
561 if (show_deleted
| show_modified
) {
562 for (i
= 0; i
< active_nr
; i
++) {
563 struct cache_entry
*ce
= active_cache
[i
];
566 if (excluded(ce
->name
) != show_ignored
)
568 err
= lstat(ce
->name
, &st
);
569 if (show_deleted
&& err
)
570 show_ce_entry(tag_removed
, ce
);
571 if (show_modified
&& ce_modified(ce
, &st
, 0))
572 show_ce_entry(tag_modified
, ce
);
578 * Prune the index to only contain stuff starting with "prefix"
580 static void prune_cache(void)
582 int pos
= cache_name_pos(prefix
, prefix_len
);
583 unsigned int first
, last
;
591 while (last
> first
) {
592 int next
= (last
+ first
) >> 1;
593 struct cache_entry
*ce
= active_cache
[next
];
594 if (!strncmp(ce
->name
, prefix
, prefix_len
)) {
603 static void verify_pathspec(void)
605 const char **p
, *n
, *prev
;
611 for (p
= pathspec
; (n
= *p
) != NULL
; p
++) {
613 for (i
= 0; i
< max
; i
++) {
615 if (prev
&& prev
[i
] != c
)
617 if (!c
|| c
== '*' || c
== '?')
630 if (prefix_offset
> max
|| memcmp(prev
, prefix
, prefix_offset
))
631 die("git-ls-files: cannot generate relative filenames containing '..'");
636 real_prefix
= xmalloc(max
+ 1);
637 memcpy(real_prefix
, prev
, max
);
638 real_prefix
[max
] = 0;
640 prefix
= real_prefix
;
643 static const char ls_files_usage
[] =
644 "git-ls-files [-z] [-t] [-v] (--[cached|deleted|others|stage|unmerged|killed|modified])* "
645 "[ --ignored ] [--exclude=<pattern>] [--exclude-from=<file>] "
646 "[ --exclude-per-directory=<filename> ] [--full-name] [--] [<file>]*";
648 int main(int argc
, const char **argv
)
653 prefix
= setup_git_directory();
655 prefix_offset
= strlen(prefix
);
656 git_config(git_default_config
);
658 for (i
= 1; i
< argc
; i
++) {
659 const char *arg
= argv
[i
];
661 if (!strcmp(arg
, "--")) {
665 if (!strcmp(arg
, "-z")) {
669 if (!strcmp(arg
, "-t") || !strcmp(arg
, "-v")) {
680 if (!strcmp(arg
, "-c") || !strcmp(arg
, "--cached")) {
684 if (!strcmp(arg
, "-d") || !strcmp(arg
, "--deleted")) {
688 if (!strcmp(arg
, "-m") || !strcmp(arg
, "--modified")) {
692 if (!strcmp(arg
, "-o") || !strcmp(arg
, "--others")) {
696 if (!strcmp(arg
, "-i") || !strcmp(arg
, "--ignored")) {
700 if (!strcmp(arg
, "-s") || !strcmp(arg
, "--stage")) {
704 if (!strcmp(arg
, "-k") || !strcmp(arg
, "--killed")) {
708 if (!strcmp(arg
, "--directory")) {
709 show_other_directories
= 1;
712 if (!strcmp(arg
, "--no-empty-directory")) {
713 hide_empty_directories
= 1;
716 if (!strcmp(arg
, "-u") || !strcmp(arg
, "--unmerged")) {
717 /* There's no point in showing unmerged unless
718 * you also show the stage information.
724 if (!strcmp(arg
, "-x") && i
+1 < argc
) {
726 add_exclude(argv
[++i
], "", 0, &exclude_list
[EXC_CMDL
]);
729 if (!strncmp(arg
, "--exclude=", 10)) {
731 add_exclude(arg
+10, "", 0, &exclude_list
[EXC_CMDL
]);
734 if (!strcmp(arg
, "-X") && i
+1 < argc
) {
736 add_excludes_from_file(argv
[++i
]);
739 if (!strncmp(arg
, "--exclude-from=", 15)) {
741 add_excludes_from_file(arg
+15);
744 if (!strncmp(arg
, "--exclude-per-directory=", 24)) {
746 exclude_per_dir
= arg
+ 24;
749 if (!strcmp(arg
, "--full-name")) {
753 if (!strcmp(arg
, "--error-unmatch")) {
758 usage(ls_files_usage
);
762 pathspec
= get_pathspec(prefix
, argv
+ i
);
764 /* Verify that the pathspec matches the prefix */
768 /* Treat unmatching pathspec elements as errors */
769 if (pathspec
&& error_unmatch
) {
771 for (num
= 0; pathspec
[num
]; num
++)
773 ps_matched
= xcalloc(1, num
);
776 if (show_ignored
&& !exc_given
) {
777 fprintf(stderr
, "%s: --ignored needs some exclude pattern\n",
782 /* With no flags, we default to showing the cached files */
783 if (!(show_stage
| show_deleted
| show_others
| show_unmerged
|
784 show_killed
| show_modified
))
793 /* We need to make sure all pathspec matched otherwise
797 for (num
= 0; pathspec
[num
]; num
++) {
800 error("pathspec '%s' did not match any.",
801 pathspec
[num
] + prefix_offset
);
804 return errors
? 1 : 0;