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
13 static int show_deleted
= 0;
14 static int show_cached
= 0;
15 static int show_others
= 0;
16 static int show_ignored
= 0;
17 static int show_stage
= 0;
18 static int show_unmerged
= 0;
19 static int show_killed
= 0;
20 static int line_terminator
= '\n';
22 static int prefix_len
= 0, prefix_offset
= 0;
23 static const char *prefix
= NULL
;
24 static const char *glob
= NULL
;
26 static const char *tag_cached
= "";
27 static const char *tag_unmerged
= "";
28 static const char *tag_removed
= "";
29 static const char *tag_other
= "";
30 static const char *tag_killed
= "";
32 static char *exclude_per_dir
= NULL
;
34 /* We maintain three exclude pattern lists:
35 * EXC_CMDL lists patterns explicitly given on the command line.
36 * EXC_DIRS lists patterns obtained from per-directory ignore files.
37 * EXC_FILE lists patterns from fallback ignore files.
42 static struct exclude_list
{
52 static void add_exclude(const char *string
, const char *base
,
53 int baselen
, struct exclude_list
*which
)
55 struct exclude
*x
= xmalloc(sizeof (*x
));
60 if (which
->nr
== which
->alloc
) {
61 which
->alloc
= alloc_nr(which
->alloc
);
62 which
->excludes
= realloc(which
->excludes
,
63 which
->alloc
* sizeof(x
));
65 which
->excludes
[which
->nr
++] = x
;
68 static int add_excludes_from_file_1(const char *fname
,
71 struct exclude_list
*which
)
77 fd
= open(fname
, O_RDONLY
);
80 size
= lseek(fd
, 0, SEEK_END
);
83 lseek(fd
, 0, SEEK_SET
);
89 if (read(fd
, buf
, size
) != size
)
94 for (i
= 0; i
< size
; i
++) {
96 if (entry
!= buf
+ i
&& entry
[0] != '#') {
98 add_exclude(entry
, base
, baselen
, which
);
111 static void add_excludes_from_file(const char *fname
)
113 if (add_excludes_from_file_1(fname
, "", 0,
114 &exclude_list
[EXC_FILE
]) < 0)
115 die("cannot use %s as an exclude file", fname
);
118 static int push_exclude_per_directory(const char *base
, int baselen
)
120 char exclude_file
[PATH_MAX
];
121 struct exclude_list
*el
= &exclude_list
[EXC_DIRS
];
122 int current_nr
= el
->nr
;
124 if (exclude_per_dir
) {
125 memcpy(exclude_file
, base
, baselen
);
126 strcpy(exclude_file
+ baselen
, exclude_per_dir
);
127 add_excludes_from_file_1(exclude_file
, base
, baselen
, el
);
132 static void pop_exclude_per_directory(int stk
)
134 struct exclude_list
*el
= &exclude_list
[EXC_DIRS
];
137 free(el
->excludes
[--el
->nr
]);
140 /* Scan the list and let the last match determines the fate.
141 * Return 1 for exclude, 0 for include and -1 for undecided.
143 static int excluded_1(const char *pathname
,
145 struct exclude_list
*el
)
150 for (i
= el
->nr
- 1; 0 <= i
; i
--) {
151 struct exclude
*x
= el
->excludes
[i
];
152 const char *exclude
= x
->pattern
;
155 if (*exclude
== '!') {
160 if (!strchr(exclude
, '/')) {
162 const char *basename
= strrchr(pathname
, '/');
163 basename
= (basename
) ? basename
+1 : pathname
;
164 if (fnmatch(exclude
, basename
, 0) == 0)
168 /* match with FNM_PATHNAME:
169 * exclude has base (baselen long) inplicitly
172 int baselen
= x
->baselen
;
176 if (pathlen
< baselen
||
177 (baselen
&& pathname
[baselen
-1] != '/') ||
178 strncmp(pathname
, x
->base
, baselen
))
181 if (fnmatch(exclude
, pathname
+baselen
,
187 return -1; /* undecided */
190 static int excluded(const char *pathname
)
192 int pathlen
= strlen(pathname
);
195 for (st
= EXC_CMDL
; st
<= EXC_FILE
; st
++) {
196 switch (excluded_1(pathname
, pathlen
, &exclude_list
[st
])) {
211 static struct nond_on_fs
**dir
;
213 static int dir_alloc
;
215 static void add_name(const char *pathname
, int len
)
217 struct nond_on_fs
*ent
;
219 if (cache_name_pos(pathname
, len
) >= 0)
222 if (nr_dir
== dir_alloc
) {
223 dir_alloc
= alloc_nr(dir_alloc
);
224 dir
= xrealloc(dir
, dir_alloc
*sizeof(ent
));
226 ent
= xmalloc(sizeof(*ent
) + len
+ 1);
228 memcpy(ent
->name
, pathname
, len
);
234 * Read a directory tree. We currently ignore anything but
235 * directories, regular files and symlinks. That's because git
236 * doesn't handle them at all yet. Maybe that will change some
239 * Also, we ignore the name ".git" (even if it is not a directory).
240 * That likely will not change.
242 static void read_directory(const char *path
, const char *base
, int baselen
)
244 DIR *dir
= opendir(path
);
249 char fullname
[MAXPATHLEN
+ 1];
250 memcpy(fullname
, base
, baselen
);
252 exclude_stk
= push_exclude_per_directory(base
, baselen
);
254 while ((de
= readdir(dir
)) != NULL
) {
257 if ((de
->d_name
[0] == '.') &&
258 (de
->d_name
[1] == 0 ||
259 !strcmp(de
->d_name
+ 1, ".") ||
260 !strcmp(de
->d_name
+ 1, "git")))
262 len
= strlen(de
->d_name
);
263 memcpy(fullname
+ baselen
, de
->d_name
, len
+1);
264 if (excluded(fullname
) != show_ignored
)
272 if (lstat(fullname
, &st
))
274 if (S_ISREG(st
.st_mode
) || S_ISLNK(st
.st_mode
))
276 if (!S_ISDIR(st
.st_mode
))
280 memcpy(fullname
+ baselen
+ len
, "/", 2);
281 read_directory(fullname
, fullname
,
288 add_name(fullname
, baselen
+ len
);
292 pop_exclude_per_directory(exclude_stk
);
296 static int cmp_name(const void *p1
, const void *p2
)
298 const struct nond_on_fs
*e1
= *(const struct nond_on_fs
**)p1
;
299 const struct nond_on_fs
*e2
= *(const struct nond_on_fs
**)p2
;
301 return cache_name_compare(e1
->name
, e1
->len
,
305 static void show_dir_entry(const char *tag
, struct nond_on_fs
*ent
)
307 int len
= prefix_len
;
308 int offset
= prefix_offset
;
311 die("git-ls-files: internal error - directory entry not superset of prefix");
313 if (glob
&& fnmatch(glob
, ent
->name
+ len
, 0))
316 printf("%s%s%c", tag
, ent
->name
+ offset
, line_terminator
);
319 static void show_killed_files(void)
322 for (i
= 0; i
< nr_dir
; i
++) {
323 struct nond_on_fs
*ent
= dir
[i
];
325 int pos
, len
, killed
= 0;
327 for (cp
= ent
->name
; cp
- ent
->name
< ent
->len
; cp
= sp
+ 1) {
328 sp
= strchr(cp
, '/');
330 /* If ent->name is prefix of an entry in the
331 * cache, it will be killed.
333 pos
= cache_name_pos(ent
->name
, ent
->len
);
335 die("bug in show-killed-files");
337 while (pos
< active_nr
&&
338 ce_stage(active_cache
[pos
]))
339 pos
++; /* skip unmerged */
340 if (active_nr
<= pos
)
342 /* pos points at a name immediately after
343 * ent->name in the cache. Does it expect
344 * ent->name to be a directory?
346 len
= ce_namelen(active_cache
[pos
]);
347 if ((ent
->len
< len
) &&
348 !strncmp(active_cache
[pos
]->name
,
349 ent
->name
, ent
->len
) &&
350 active_cache
[pos
]->name
[ent
->len
] == '/')
354 if (0 <= cache_name_pos(ent
->name
, sp
- ent
->name
)) {
355 /* If any of the leading directories in
356 * ent->name is registered in the cache,
357 * ent->name will be killed.
364 show_dir_entry(tag_killed
, dir
[i
]);
368 static void show_ce_entry(const char *tag
, struct cache_entry
*ce
)
370 int len
= prefix_len
;
371 int offset
= prefix_offset
;
373 if (len
>= ce_namelen(ce
))
374 die("git-ls-files: internal error - cache entry not superset of prefix");
376 if (glob
&& fnmatch(glob
, ce
->name
+ len
, 0))
380 printf("%s%s%c", tag
, ce
->name
+ offset
, line_terminator
);
382 printf("%s%06o %s %d\t%s%c",
385 sha1_to_hex(ce
->sha1
),
387 ce
->name
+ offset
, line_terminator
);
390 static void show_files(void)
394 /* For cached/deleted files we don't need to even do the readdir */
395 if (show_others
|| show_killed
) {
396 const char *path
= ".", *base
= "";
397 int baselen
= prefix_len
;
400 path
= base
= prefix
;
401 read_directory(path
, base
, baselen
);
402 qsort(dir
, nr_dir
, sizeof(struct nond_on_fs
*), cmp_name
);
404 for (i
= 0; i
< nr_dir
; i
++)
405 show_dir_entry(tag_other
, dir
[i
]);
409 if (show_cached
| show_stage
) {
410 for (i
= 0; i
< active_nr
; i
++) {
411 struct cache_entry
*ce
= active_cache
[i
];
412 if (excluded(ce
->name
) != show_ignored
)
414 if (show_unmerged
&& !ce_stage(ce
))
416 show_ce_entry(ce_stage(ce
) ? tag_unmerged
: tag_cached
, ce
);
420 for (i
= 0; i
< active_nr
; i
++) {
421 struct cache_entry
*ce
= active_cache
[i
];
423 if (excluded(ce
->name
) != show_ignored
)
425 if (!lstat(ce
->name
, &st
))
427 show_ce_entry(tag_removed
, ce
);
433 * Prune the index to only contain stuff starting with "prefix"
435 static void prune_cache(void)
437 int pos
= cache_name_pos(prefix
, prefix_len
);
438 unsigned int first
, last
;
446 while (last
> first
) {
447 int next
= (last
+ first
) >> 1;
448 struct cache_entry
*ce
= active_cache
[next
];
449 if (!strncmp(ce
->name
, prefix
, prefix_len
)) {
459 * If the glob starts with a subdirectory, append it to
460 * the prefix instead, for more efficient operation.
462 * But we do not update the "prefix_offset", which tells
463 * how much of the name to ignore at printout.
465 static void extend_prefix(void)
467 const char *p
, *slash
;
472 while ((c
= *p
++) != '\0') {
479 int len
= slash
- glob
;
480 char *newprefix
= xmalloc(len
+ prefix_len
+ 1);
481 memcpy(newprefix
, prefix
, prefix_len
);
482 memcpy(newprefix
+ prefix_len
, glob
, len
);
484 newprefix
[prefix_len
] = 0;
486 glob
= *slash
? slash
: NULL
;
490 static const char ls_files_usage
[] =
491 "git-ls-files [-z] [-t] (--[cached|deleted|others|stage|unmerged|killed])* "
492 "[ --ignored ] [--exclude=<pattern>] [--exclude-from=<file>] "
493 "[ --exclude-per-directory=<filename> ]";
495 int main(int argc
, char **argv
)
500 prefix
= setup_git_directory();
502 prefix_offset
= prefix_len
= strlen(prefix
);
504 for (i
= 1; i
< argc
; i
++) {
507 if (!strcmp(arg
, "-z")) {
511 if (!strcmp(arg
, "-t")) {
519 if (!strcmp(arg
, "-c") || !strcmp(arg
, "--cached")) {
523 if (!strcmp(arg
, "-d") || !strcmp(arg
, "--deleted")) {
527 if (!strcmp(arg
, "-o") || !strcmp(arg
, "--others")) {
531 if (!strcmp(arg
, "-i") || !strcmp(arg
, "--ignored")) {
535 if (!strcmp(arg
, "-s") || !strcmp(arg
, "--stage")) {
539 if (!strcmp(arg
, "-k") || !strcmp(arg
, "--killed")) {
543 if (!strcmp(arg
, "-u") || !strcmp(arg
, "--unmerged")) {
544 /* There's no point in showing unmerged unless
545 * you also show the stage information.
551 if (!strcmp(arg
, "-x") && i
+1 < argc
) {
553 add_exclude(argv
[++i
], "", 0, &exclude_list
[EXC_CMDL
]);
556 if (!strncmp(arg
, "--exclude=", 10)) {
558 add_exclude(arg
+10, "", 0, &exclude_list
[EXC_CMDL
]);
561 if (!strcmp(arg
, "-X") && i
+1 < argc
) {
563 add_excludes_from_file(argv
[++i
]);
566 if (!strncmp(arg
, "--exclude-from=", 15)) {
568 add_excludes_from_file(arg
+15);
571 if (!strncmp(arg
, "--exclude-per-directory=", 24)) {
573 exclude_per_dir
= arg
+ 24;
576 if (!strcmp(arg
, "--full-name")) {
580 if (glob
|| *arg
== '-')
581 usage(ls_files_usage
);
588 if (show_ignored
&& !exc_given
) {
589 fprintf(stderr
, "%s: --ignored needs some exclude pattern\n",
594 /* With no flags, we default to showing the cached files */
595 if (!(show_stage
| show_deleted
| show_others
| show_unmerged
| show_killed
))