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
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';
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
;
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
= "";
41 * Match a pathspec against a filename. The first "len" characters
42 * are the common prefix
44 static int match(const char **spec
, char *ps_matched
,
45 const char *filename
, int len
)
49 while ((m
= *spec
++) != NULL
) {
50 int matchlen
= strlen(m
+ len
);
54 if (!strncmp(m
+ len
, filename
+ len
, matchlen
)) {
55 if (m
[len
+ matchlen
- 1] == '/')
57 switch (filename
[len
+ matchlen
]) {
62 if (!fnmatch(m
+ len
, filename
+ len
, 0))
75 static void show_dir_entry(const char *tag
, struct dir_entry
*ent
)
78 int offset
= prefix_offset
;
81 die("git-ls-files: internal error - directory entry not superset of prefix");
83 if (pathspec
&& !match(pathspec
, ps_matched
, ent
->name
, len
))
87 write_name_quoted("", 0, ent
->name
+ offset
, line_terminator
, stdout
);
88 putchar(line_terminator
);
91 static void show_other_files(struct dir_struct
*dir
)
97 * Skip matching and unmerged entries for the paths,
98 * since we want just "others".
100 * (Matching entries are normally pruned during
101 * the directory tree walk, but will show up for
102 * gitlinks because we don't necessarily have
103 * dir->show_other_directories set to suppress
106 for (i
= 0; i
< dir
->nr
; i
++) {
107 struct dir_entry
*ent
= dir
->entries
[i
];
109 struct cache_entry
*ce
;
112 * Remove the '/' at the end that directory
113 * walking adds for directory entries.
116 if (len
&& ent
->name
[len
-1] == '/')
118 pos
= cache_name_pos(ent
->name
, len
);
120 continue; /* exact match */
122 if (pos
< active_nr
) {
123 ce
= active_cache
[pos
];
124 if (ce_namelen(ce
) == len
&&
125 !memcmp(ce
->name
, ent
->name
, len
))
126 continue; /* Yup, this one exists unmerged */
128 show_dir_entry(tag_other
, ent
);
132 static void show_killed_files(struct dir_struct
*dir
)
135 for (i
= 0; i
< dir
->nr
; i
++) {
136 struct dir_entry
*ent
= dir
->entries
[i
];
138 int pos
, len
, killed
= 0;
140 for (cp
= ent
->name
; cp
- ent
->name
< ent
->len
; cp
= sp
+ 1) {
141 sp
= strchr(cp
, '/');
143 /* If ent->name is prefix of an entry in the
144 * cache, it will be killed.
146 pos
= cache_name_pos(ent
->name
, ent
->len
);
148 die("bug in show-killed-files");
150 while (pos
< active_nr
&&
151 ce_stage(active_cache
[pos
]))
152 pos
++; /* skip unmerged */
153 if (active_nr
<= pos
)
155 /* pos points at a name immediately after
156 * ent->name in the cache. Does it expect
157 * ent->name to be a directory?
159 len
= ce_namelen(active_cache
[pos
]);
160 if ((ent
->len
< len
) &&
161 !strncmp(active_cache
[pos
]->name
,
162 ent
->name
, ent
->len
) &&
163 active_cache
[pos
]->name
[ent
->len
] == '/')
167 if (0 <= cache_name_pos(ent
->name
, sp
- ent
->name
)) {
168 /* If any of the leading directories in
169 * ent->name is registered in the cache,
170 * ent->name will be killed.
177 show_dir_entry(tag_killed
, dir
->entries
[i
]);
181 static void show_ce_entry(const char *tag
, struct cache_entry
*ce
)
183 int len
= prefix_len
;
184 int offset
= prefix_offset
;
186 if (len
>= ce_namelen(ce
))
187 die("git-ls-files: internal error - cache entry not superset of prefix");
189 if (pathspec
&& !match(pathspec
, ps_matched
, ce
->name
, len
))
192 if (tag
&& *tag
&& show_valid_bit
&&
193 (ce
->ce_flags
& htons(CE_VALID
))) {
194 static char alttag
[4];
195 memcpy(alttag
, tag
, 3);
197 alttag
[0] = tolower(tag
[0]);
198 else if (tag
[0] == '?')
211 write_name_quoted("", 0, ce
->name
+ offset
,
212 line_terminator
, stdout
);
213 putchar(line_terminator
);
216 printf("%s%06o %s %d\t",
219 abbrev
? find_unique_abbrev(ce
->sha1
,abbrev
)
220 : sha1_to_hex(ce
->sha1
),
222 write_name_quoted("", 0, ce
->name
+ offset
,
223 line_terminator
, stdout
);
224 putchar(line_terminator
);
228 static void show_files(struct dir_struct
*dir
, const char *prefix
)
232 /* For cached/deleted files we don't need to even do the readdir */
233 if (show_others
|| show_killed
) {
234 const char *path
= ".", *base
= "";
235 int baselen
= prefix_len
;
238 path
= base
= prefix
;
239 read_directory(dir
, path
, base
, baselen
, pathspec
);
241 show_other_files(dir
);
243 show_killed_files(dir
);
245 if (show_cached
| show_stage
) {
246 for (i
= 0; i
< active_nr
; i
++) {
247 struct cache_entry
*ce
= active_cache
[i
];
248 if (excluded(dir
, ce
->name
) != dir
->show_ignored
)
250 if (show_unmerged
&& !ce_stage(ce
))
252 if (ce
->ce_flags
& htons(CE_UPDATE
))
254 show_ce_entry(ce_stage(ce
) ? tag_unmerged
: tag_cached
, ce
);
257 if (show_deleted
| show_modified
) {
258 for (i
= 0; i
< active_nr
; i
++) {
259 struct cache_entry
*ce
= active_cache
[i
];
262 if (excluded(dir
, ce
->name
) != dir
->show_ignored
)
264 err
= lstat(ce
->name
, &st
);
265 if (show_deleted
&& err
)
266 show_ce_entry(tag_removed
, ce
);
267 if (show_modified
&& ce_modified(ce
, &st
, 0))
268 show_ce_entry(tag_modified
, ce
);
274 * Prune the index to only contain stuff starting with "prefix"
276 static void prune_cache(const char *prefix
)
278 int pos
= cache_name_pos(prefix
, prefix_len
);
279 unsigned int first
, last
;
287 while (last
> first
) {
288 int next
= (last
+ first
) >> 1;
289 struct cache_entry
*ce
= active_cache
[next
];
290 if (!strncmp(ce
->name
, prefix
, prefix_len
)) {
299 static const char *verify_pathspec(const char *prefix
)
301 const char **p
, *n
, *prev
;
306 for (p
= pathspec
; (n
= *p
) != NULL
; p
++) {
308 for (i
= 0; i
< max
; i
++) {
310 if (prev
&& prev
[i
] != c
)
312 if (!c
|| c
== '*' || c
== '?')
325 if (prefix_offset
> max
|| memcmp(prev
, prefix
, prefix_offset
))
326 die("git-ls-files: cannot generate relative filenames containing '..'");
329 return max
? xmemdupz(prev
, max
) : NULL
;
333 * Read the tree specified with --with-tree option
334 * (typically, HEAD) into stage #1 and then
335 * squash them down to stage #0. This is used for
336 * --error-unmatch to list and check the path patterns
337 * that were given from the command line. We are not
338 * going to write this index out.
340 static void overlay_tree(const char *tree_name
, const char *prefix
)
343 unsigned char sha1
[20];
345 struct cache_entry
*last_stage0
= NULL
;
348 if (get_sha1(tree_name
, sha1
))
349 die("tree-ish %s not found.", tree_name
);
350 tree
= parse_tree_indirect(sha1
);
352 die("bad tree-ish %s", tree_name
);
354 /* Hoist the unmerged entries up to stage #3 to make room */
355 for (i
= 0; i
< active_nr
; i
++) {
356 struct cache_entry
*ce
= active_cache
[i
];
359 ce
->ce_flags
|= htons(CE_STAGEMASK
);
363 static const char *(matchbuf
[2]);
364 matchbuf
[0] = prefix
;
369 if (read_tree(tree
, 1, match
))
370 die("unable to read tree entries %s", tree_name
);
372 for (i
= 0; i
< active_nr
; i
++) {
373 struct cache_entry
*ce
= active_cache
[i
];
374 switch (ce_stage(ce
)) {
382 * If there is stage #0 entry for this, we do not
383 * need to show it. We use CE_UPDATE bit to mark
387 !strcmp(last_stage0
->name
, ce
->name
))
388 ce
->ce_flags
|= htons(CE_UPDATE
);
393 static const char ls_files_usage
[] =
394 "git-ls-files [-z] [-t] [-v] (--[cached|deleted|others|stage|unmerged|killed|modified])* "
395 "[ --ignored ] [--exclude=<pattern>] [--exclude-from=<file>] "
396 "[ --exclude-per-directory=<filename> ] [--full-name] [--abbrev] "
399 int cmd_ls_files(int argc
, const char **argv
, const char *prefix
)
402 int exc_given
= 0, require_work_tree
= 0;
403 struct dir_struct dir
;
405 memset(&dir
, 0, sizeof(dir
));
407 prefix_offset
= strlen(prefix
);
408 git_config(git_default_config
);
410 for (i
= 1; i
< argc
; i
++) {
411 const char *arg
= argv
[i
];
413 if (!strcmp(arg
, "--")) {
417 if (!strcmp(arg
, "-z")) {
421 if (!strcmp(arg
, "-t") || !strcmp(arg
, "-v")) {
432 if (!strcmp(arg
, "-c") || !strcmp(arg
, "--cached")) {
436 if (!strcmp(arg
, "-d") || !strcmp(arg
, "--deleted")) {
440 if (!strcmp(arg
, "-m") || !strcmp(arg
, "--modified")) {
442 require_work_tree
= 1;
445 if (!strcmp(arg
, "-o") || !strcmp(arg
, "--others")) {
447 require_work_tree
= 1;
450 if (!strcmp(arg
, "-i") || !strcmp(arg
, "--ignored")) {
451 dir
.show_ignored
= 1;
452 require_work_tree
= 1;
455 if (!strcmp(arg
, "-s") || !strcmp(arg
, "--stage")) {
459 if (!strcmp(arg
, "-k") || !strcmp(arg
, "--killed")) {
461 require_work_tree
= 1;
464 if (!strcmp(arg
, "--directory")) {
465 dir
.show_other_directories
= 1;
468 if (!strcmp(arg
, "--no-empty-directory")) {
469 dir
.hide_empty_directories
= 1;
472 if (!strcmp(arg
, "-u") || !strcmp(arg
, "--unmerged")) {
473 /* There's no point in showing unmerged unless
474 * you also show the stage information.
480 if (!strcmp(arg
, "-x") && i
+1 < argc
) {
482 add_exclude(argv
[++i
], "", 0, &dir
.exclude_list
[EXC_CMDL
]);
485 if (!prefixcmp(arg
, "--exclude=")) {
487 add_exclude(arg
+10, "", 0, &dir
.exclude_list
[EXC_CMDL
]);
490 if (!strcmp(arg
, "-X") && i
+1 < argc
) {
492 add_excludes_from_file(&dir
, argv
[++i
]);
495 if (!prefixcmp(arg
, "--exclude-from=")) {
497 add_excludes_from_file(&dir
, arg
+15);
500 if (!prefixcmp(arg
, "--exclude-per-directory=")) {
502 dir
.exclude_per_dir
= arg
+ 24;
505 if (!strcmp(arg
, "--full-name")) {
509 if (!strcmp(arg
, "--error-unmatch")) {
513 if (!prefixcmp(arg
, "--with-tree=")) {
514 with_tree
= arg
+ 12;
517 if (!prefixcmp(arg
, "--abbrev=")) {
518 abbrev
= strtoul(arg
+9, NULL
, 10);
519 if (abbrev
&& abbrev
< MINIMUM_ABBREV
)
520 abbrev
= MINIMUM_ABBREV
;
521 else if (abbrev
> 40)
525 if (!strcmp(arg
, "--abbrev")) {
526 abbrev
= DEFAULT_ABBREV
;
530 usage(ls_files_usage
);
534 if (require_work_tree
&& !is_inside_work_tree()) {
535 const char *work_tree
= get_git_work_tree();
536 if (!work_tree
|| chdir(work_tree
))
537 die("This operation must be run in a work tree");
540 pathspec
= get_pathspec(prefix
, argv
+ i
);
542 /* Verify that the pathspec matches the prefix */
544 prefix
= verify_pathspec(prefix
);
546 /* Treat unmatching pathspec elements as errors */
547 if (pathspec
&& error_unmatch
) {
549 for (num
= 0; pathspec
[num
]; num
++)
551 ps_matched
= xcalloc(1, num
);
554 if (dir
.show_ignored
&& !exc_given
) {
555 fprintf(stderr
, "%s: --ignored needs some exclude pattern\n",
560 /* With no flags, we default to showing the cached files */
561 if (!(show_stage
| show_deleted
| show_others
| show_unmerged
|
562 show_killed
| show_modified
))
570 * Basic sanity check; show-stages and show-unmerged
571 * would not make any sense with this option.
573 if (show_stage
|| show_unmerged
)
574 die("ls-files --with-tree is incompatible with -s or -u");
575 overlay_tree(with_tree
, prefix
);
577 show_files(&dir
, prefix
);
580 /* We need to make sure all pathspec matched otherwise
584 for (num
= 0; pathspec
[num
]; num
++) {
585 int other
, found_dup
;
590 * The caller might have fed identical pathspec
591 * twice. Do not barf on such a mistake.
593 for (found_dup
= other
= 0;
594 !found_dup
&& pathspec
[other
];
596 if (other
== num
|| !ps_matched
[other
])
598 if (!strcmp(pathspec
[other
], pathspec
[num
]))
600 * Ok, we have a match already.
607 error("pathspec '%s' did not match any file(s) known to git.",
608 pathspec
[num
] + prefix_offset
);
613 fprintf(stderr
, "Did you forget to 'git add'?\n");
615 return errors
? 1 : 0;