3 #include "unpack-trees.h"
5 #include "object-store.h"
9 static const char *get_mode(const char *str
, unsigned int *modep
)
12 unsigned int mode
= 0;
17 while ((c
= *str
++) != ' ') {
18 if (c
< '0' || c
> '7')
20 mode
= (mode
<< 3) + (c
- '0');
26 static int decode_tree_entry(struct tree_desc
*desc
, const char *buf
, unsigned long size
, struct strbuf
*err
)
29 unsigned int mode
, len
;
30 const unsigned hashsz
= the_hash_algo
->rawsz
;
32 if (size
< hashsz
+ 3 || buf
[size
- (hashsz
+ 1)]) {
33 strbuf_addstr(err
, _("too-short tree object"));
37 path
= get_mode(buf
, &mode
);
39 strbuf_addstr(err
, _("malformed mode in tree entry"));
43 strbuf_addstr(err
, _("empty filename in tree entry"));
46 len
= strlen(path
) + 1;
48 /* Initialize the descriptor entry */
49 desc
->entry
.path
= path
;
50 desc
->entry
.mode
= canon_mode(mode
);
51 desc
->entry
.pathlen
= len
- 1;
52 hashcpy(desc
->entry
.oid
.hash
, (const unsigned char *)path
+ len
);
57 static int init_tree_desc_internal(struct tree_desc
*desc
, const void *buffer
, unsigned long size
, struct strbuf
*err
)
59 desc
->buffer
= buffer
;
62 return decode_tree_entry(desc
, buffer
, size
, err
);
66 void init_tree_desc(struct tree_desc
*desc
, const void *buffer
, unsigned long size
)
68 struct strbuf err
= STRBUF_INIT
;
69 if (init_tree_desc_internal(desc
, buffer
, size
, &err
))
74 int init_tree_desc_gently(struct tree_desc
*desc
, const void *buffer
, unsigned long size
)
76 struct strbuf err
= STRBUF_INIT
;
77 int result
= init_tree_desc_internal(desc
, buffer
, size
, &err
);
84 void *fill_tree_descriptor(struct tree_desc
*desc
, const struct object_id
*oid
)
86 unsigned long size
= 0;
90 buf
= read_object_with_reference(oid
, tree_type
, &size
, NULL
);
92 die("unable to read tree %s", oid_to_hex(oid
));
94 init_tree_desc(desc
, buf
, size
);
98 static void entry_clear(struct name_entry
*a
)
100 memset(a
, 0, sizeof(*a
));
103 static void entry_extract(struct tree_desc
*t
, struct name_entry
*a
)
108 static int update_tree_entry_internal(struct tree_desc
*desc
, struct strbuf
*err
)
110 const void *buf
= desc
->buffer
;
111 const unsigned char *end
= (const unsigned char *)desc
->entry
.path
+ desc
->entry
.pathlen
+ 1 + the_hash_algo
->rawsz
;
112 unsigned long size
= desc
->size
;
113 unsigned long len
= end
- (const unsigned char *)buf
;
116 die(_("too-short tree file"));
122 return decode_tree_entry(desc
, buf
, size
, err
);
126 void update_tree_entry(struct tree_desc
*desc
)
128 struct strbuf err
= STRBUF_INIT
;
129 if (update_tree_entry_internal(desc
, &err
))
131 strbuf_release(&err
);
134 int update_tree_entry_gently(struct tree_desc
*desc
)
136 struct strbuf err
= STRBUF_INIT
;
137 if (update_tree_entry_internal(desc
, &err
)) {
138 error("%s", err
.buf
);
139 strbuf_release(&err
);
140 /* Stop processing this tree after error */
144 strbuf_release(&err
);
148 int tree_entry(struct tree_desc
*desc
, struct name_entry
*entry
)
153 *entry
= desc
->entry
;
154 update_tree_entry(desc
);
158 int tree_entry_gently(struct tree_desc
*desc
, struct name_entry
*entry
)
163 *entry
= desc
->entry
;
164 if (update_tree_entry_gently(desc
))
169 void setup_traverse_info(struct traverse_info
*info
, const char *base
)
171 int pathlen
= strlen(base
);
172 static struct traverse_info dummy
;
174 memset(info
, 0, sizeof(*info
));
175 if (pathlen
&& base
[pathlen
-1] == '/')
177 info
->pathlen
= pathlen
? pathlen
+ 1 : 0;
178 info
->name
.path
= base
;
179 info
->name
.pathlen
= pathlen
;
181 hashcpy(info
->name
.oid
.hash
, (const unsigned char *)base
+ pathlen
+ 1);
186 char *make_traverse_path(char *path
, const struct traverse_info
*info
, const struct name_entry
*n
)
188 int len
= tree_entry_len(n
);
189 int pathlen
= info
->pathlen
;
191 path
[pathlen
+ len
] = 0;
193 memcpy(path
+ pathlen
, n
->path
, len
);
196 path
[--pathlen
] = '/';
198 len
= tree_entry_len(n
);
205 struct tree_desc_skip
{
206 struct tree_desc_skip
*prev
;
212 struct tree_desc_skip
*skip
;
215 static int check_entry_match(const char *a
, int a_len
, const char *b
, int b_len
)
218 * The caller wants to pick *a* from a tree or nothing.
219 * We are looking at *b* in a tree.
221 * (0) If a and b are the same name, we are trivially happy.
223 * There are three possibilities where *a* could be hiding
226 * (1) *a* == "t", *b* == "ab" i.e. *b* sorts earlier than *a* no
228 * (2) *a* == "t", *b* == "t-2" and "t" is a subtree in the tree;
229 * (3) *a* == "t-2", *b* == "t" and "t-2" is a blob in the tree.
231 * Otherwise we know *a* won't appear in the tree without
235 int cmp
= name_compare(a
, a_len
, b
, b_len
);
237 /* Most common case first -- reading sync'd trees */
242 /* a comes after b; it does not matter if it is case (3)
243 if (b_len < a_len && !memcmp(a, b, b_len) && a[b_len] < '/')
246 return 1; /* keep looking */
249 /* b comes after a; are we looking at case (2)? */
250 if (a_len
< b_len
&& !memcmp(a
, b
, a_len
) && b
[a_len
] < '/')
251 return 1; /* keep looking */
253 return -1; /* a cannot appear in the tree */
257 * From the extended tree_desc, extract the first name entry, while
258 * paying attention to the candidate "first" name. Most importantly,
259 * when looking for an entry, if there are entries that sorts earlier
260 * in the tree object representation than that name, skip them and
261 * process the named entry first. We will remember that we haven't
262 * processed the first entry yet, and in the later call skip the
263 * entry we processed early when update_extended_entry() is called.
265 * E.g. if the underlying tree object has these entries:
272 * and the "first" asks for "t", remember that we still need to
273 * process "t-1" and "t-2" but extract "t". After processing the
274 * entry "t" from this call, the caller will let us know by calling
275 * update_extended_entry() that we can remember "t" has been processed
279 static void extended_entry_extract(struct tree_desc_x
*t
,
280 struct name_entry
*a
,
286 struct tree_desc probe
;
287 struct tree_desc_skip
*skip
;
290 * Extract the first entry from the tree_desc, but skip the
291 * ones that we already returned in earlier rounds.
296 break; /* not found */
298 entry_extract(&t
->d
, a
);
299 for (skip
= t
->skip
; skip
; skip
= skip
->prev
)
300 if (a
->path
== skip
->ptr
)
304 /* We have processed this entry already. */
305 update_tree_entry(&t
->d
);
308 if (!first
|| !a
->path
)
312 * The caller wants "first" from this tree, or nothing.
315 len
= tree_entry_len(a
);
316 switch (check_entry_match(first
, first_len
, path
, len
)) {
326 * We need to look-ahead -- we suspect that a subtree whose
327 * name is "first" may be hiding behind the current entry "path".
331 entry_extract(&probe
, a
);
333 len
= tree_entry_len(a
);
334 switch (check_entry_match(first
, first_len
, path
, len
)) {
340 update_tree_entry(&probe
);
348 static void update_extended_entry(struct tree_desc_x
*t
, struct name_entry
*a
)
350 if (t
->d
.entry
.path
== a
->path
) {
351 update_tree_entry(&t
->d
);
353 /* we have returned this entry early */
354 struct tree_desc_skip
*skip
= xmalloc(sizeof(*skip
));
356 skip
->prev
= t
->skip
;
361 static void free_extended_entry(struct tree_desc_x
*t
)
363 struct tree_desc_skip
*p
, *s
;
365 for (s
= t
->skip
; s
; s
= p
) {
371 static inline int prune_traversal(struct name_entry
*e
,
372 struct traverse_info
*info
,
374 int still_interesting
)
376 if (!info
->pathspec
|| still_interesting
== 2)
378 if (still_interesting
< 0)
379 return still_interesting
;
380 return tree_entry_interesting(e
, base
, 0, info
->pathspec
);
383 int traverse_trees(int n
, struct tree_desc
*t
, struct traverse_info
*info
)
386 struct name_entry
*entry
= xmalloc(n
*sizeof(*entry
));
388 struct tree_desc_x
*tx
= xcalloc(n
, sizeof(*tx
));
389 struct strbuf base
= STRBUF_INIT
;
393 for (i
= 0; i
< n
; i
++)
397 strbuf_grow(&base
, info
->pathlen
);
398 make_traverse_path(base
.buf
, info
->prev
, &info
->name
);
399 base
.buf
[info
->pathlen
-1] = '/';
400 strbuf_setlen(&base
, info
->pathlen
);
401 traverse_path
= xstrndup(base
.buf
, info
->pathlen
);
403 traverse_path
= xstrndup(info
->name
.path
, info
->pathlen
);
405 info
->traverse_path
= traverse_path
;
408 unsigned long mask
, dirmask
;
409 const char *first
= NULL
;
411 struct name_entry
*e
= NULL
;
414 for (i
= 0; i
< n
; i
++) {
416 extended_entry_extract(tx
+ i
, e
, NULL
, 0);
420 * A tree may have "t-2" at the current location even
421 * though it may have "t" that is a subtree behind it,
422 * and another tree may return "t". We want to grab
423 * all "t" from all trees to match in such a case.
425 for (i
= 0; i
< n
; i
++) {
429 len
= tree_entry_len(e
);
435 if (name_compare(e
->path
, len
, first
, first_len
) < 0) {
442 for (i
= 0; i
< n
; i
++) {
444 extended_entry_extract(tx
+ i
, e
, first
, first_len
);
445 /* Cull the ones that are not the earliest */
448 len
= tree_entry_len(e
);
449 if (name_compare(e
->path
, len
, first
, first_len
))
454 /* Now we have in entry[i] the earliest name from the trees */
457 for (i
= 0; i
< n
; i
++) {
461 if (S_ISDIR(entry
[i
].mode
))
467 interesting
= prune_traversal(e
, info
, &base
, interesting
);
471 trees_used
= info
->fn(n
, mask
, dirmask
, entry
, info
);
472 if (trees_used
< 0) {
474 if (!info
->show_all_errors
)
479 for (i
= 0; i
< n
; i
++)
480 if (mask
& (1ul << i
))
481 update_extended_entry(tx
+ i
, entry
+ i
);
484 for (i
= 0; i
< n
; i
++)
485 free_extended_entry(tx
+ i
);
488 info
->traverse_path
= NULL
;
489 strbuf_release(&base
);
496 struct object_id oid
;
499 static int find_tree_entry(struct tree_desc
*t
, const char *name
, struct object_id
*result
, unsigned *mode
)
501 int namelen
= strlen(name
);
504 struct object_id oid
;
507 oidcpy(&oid
, tree_entry_extract(t
, &entry
, mode
));
508 entrylen
= tree_entry_len(&t
->entry
);
509 update_tree_entry(t
);
510 if (entrylen
> namelen
)
512 cmp
= memcmp(name
, entry
, entrylen
);
517 if (entrylen
== namelen
) {
518 oidcpy(result
, &oid
);
521 if (name
[entrylen
] != '/')
525 if (++entrylen
== namelen
) {
526 oidcpy(result
, &oid
);
529 return get_tree_entry(&oid
, name
+ entrylen
, result
, mode
);
534 int get_tree_entry(const struct object_id
*tree_oid
, const char *name
, struct object_id
*oid
, unsigned *mode
)
539 struct object_id root
;
541 tree
= read_object_with_reference(tree_oid
, tree_type
, &size
, &root
);
545 if (name
[0] == '\0') {
555 init_tree_desc(&t
, tree
, size
);
556 retval
= find_tree_entry(&t
, name
, oid
, mode
);
563 * This is Linux's built-in max for the number of symlinks to follow.
564 * That limit, of course, does not affect git, but it's a reasonable
567 #define GET_TREE_ENTRY_FOLLOW_SYMLINKS_MAX_LINKS 40
570 * Find a tree entry by following symlinks in tree_sha (which is
571 * assumed to be the root of the repository). In the event that a
572 * symlink points outside the repository (e.g. a link to /foo or a
573 * root-level link to ../foo), the portion of the link which is
574 * outside the repository will be returned in result_path, and *mode
575 * will be set to 0. It is assumed that result_path is uninitialized.
576 * If there are no symlinks, or the end result of the symlink chain
577 * points to an object inside the repository, result will be filled in
578 * with the sha1 of the found object, and *mode will hold the mode of
581 * See the code for enum follow_symlink_result for a description of
584 enum follow_symlinks_result
get_tree_entry_follow_symlinks(struct object_id
*tree_oid
, const char *name
, struct object_id
*result
, struct strbuf
*result_path
, unsigned *mode
)
586 int retval
= MISSING_OBJECT
;
587 struct dir_state
*parents
= NULL
;
588 size_t parents_alloc
= 0;
589 size_t i
, parents_nr
= 0;
590 struct object_id current_tree_oid
;
591 struct strbuf namebuf
= STRBUF_INIT
;
593 int follows_remaining
= GET_TREE_ENTRY_FOLLOW_SYMLINKS_MAX_LINKS
;
595 init_tree_desc(&t
, NULL
, 0UL);
596 strbuf_addstr(&namebuf
, name
);
597 oidcpy(¤t_tree_oid
, tree_oid
);
602 char *remainder
= NULL
;
606 struct object_id root
;
608 tree
= read_object_with_reference(¤t_tree_oid
,
614 ALLOC_GROW(parents
, parents_nr
+ 1, parents_alloc
);
615 parents
[parents_nr
].tree
= tree
;
616 parents
[parents_nr
].size
= size
;
617 oidcpy(&parents
[parents_nr
].oid
, &root
);
620 if (namebuf
.buf
[0] == '\0') {
621 oidcpy(result
, &root
);
630 init_tree_desc(&t
, tree
, size
);
633 /* Handle symlinks to e.g. a//b by removing leading slashes */
634 while (namebuf
.buf
[0] == '/') {
635 strbuf_remove(&namebuf
, 0, 1);
638 /* Split namebuf into a first component and a remainder */
639 if ((first_slash
= strchr(namebuf
.buf
, '/'))) {
641 remainder
= first_slash
+ 1;
644 if (!strcmp(namebuf
.buf
, "..")) {
645 struct dir_state
*parent
;
647 * We could end up with .. in the namebuf if it
648 * appears in a symlink.
651 if (parents_nr
== 1) {
654 strbuf_add(result_path
, namebuf
.buf
,
660 parent
= &parents
[parents_nr
- 1];
663 parent
= &parents
[parents_nr
- 1];
664 init_tree_desc(&t
, parent
->tree
, parent
->size
);
665 strbuf_remove(&namebuf
, 0, remainder
? 3 : 2);
669 /* We could end up here via a symlink to dir/.. */
670 if (namebuf
.buf
[0] == '\0') {
671 oidcpy(result
, &parents
[parents_nr
- 1].oid
);
676 /* Look up the first (or only) path component in the tree. */
677 find_result
= find_tree_entry(&t
, namebuf
.buf
,
678 ¤t_tree_oid
, mode
);
683 if (S_ISDIR(*mode
)) {
685 oidcpy(result
, ¤t_tree_oid
);
689 /* Descend the tree */
691 strbuf_remove(&namebuf
, 0,
692 1 + first_slash
- namebuf
.buf
);
693 } else if (S_ISREG(*mode
)) {
695 oidcpy(result
, ¤t_tree_oid
);
701 } else if (S_ISLNK(*mode
)) {
702 /* Follow a symlink */
703 unsigned long link_len
;
705 char *contents
, *contents_start
;
706 struct dir_state
*parent
;
707 enum object_type type
;
709 if (follows_remaining
-- == 0) {
710 /* Too many symlinks followed */
711 retval
= SYMLINK_LOOP
;
716 * At this point, we have followed at a least
717 * one symlink, so on error we need to report this.
719 retval
= DANGLING_SYMLINK
;
721 contents
= read_object_file(¤t_tree_oid
, &type
,
727 if (contents
[0] == '/') {
728 strbuf_addstr(result_path
, contents
);
736 len
= first_slash
- namebuf
.buf
;
740 contents_start
= contents
;
742 parent
= &parents
[parents_nr
- 1];
743 init_tree_desc(&t
, parent
->tree
, parent
->size
);
744 strbuf_splice(&namebuf
, 0, len
,
745 contents_start
, link_len
);
747 namebuf
.buf
[link_len
] = '/';
752 for (i
= 0; i
< parents_nr
; i
++)
753 free(parents
[i
].tree
);
756 strbuf_release(&namebuf
);
760 static int match_entry(const struct pathspec_item
*item
,
761 const struct name_entry
*entry
, int pathlen
,
762 const char *match
, int matchlen
,
763 enum interesting
*never_interesting
)
765 int m
= -1; /* signals that we haven't called strncmp() */
767 if (item
->magic
& PATHSPEC_ICASE
)
769 * "Never interesting" trick requires exact
770 * matching. We could do something clever with inexact
771 * matching, but it's trickier (and not to forget that
772 * strcasecmp is locale-dependent, at least in
773 * glibc). Just disable it for now. It can't be worse
774 * than the wildcard's codepath of '[Tt][Hi][Is][Ss]'
777 *never_interesting
= entry_not_interesting
;
778 else if (*never_interesting
!= entry_not_interesting
) {
780 * We have not seen any match that sorts later
781 * than the current path.
785 * Does match sort strictly earlier than path
786 * with their common parts?
788 m
= strncmp(match
, entry
->path
,
789 (matchlen
< pathlen
) ? matchlen
: pathlen
);
794 * If we come here even once, that means there is at
795 * least one pathspec that would sort equal to or
796 * later than the path we are currently looking at.
797 * In other words, if we have never reached this point
798 * after iterating all pathspecs, it means all
799 * pathspecs are either outside of base, or inside the
800 * base but sorts strictly earlier than the current
801 * one. In either case, they will never match the
802 * subsequent entries. In such a case, we initialized
803 * the variable to -1 and that is what will be
804 * returned, allowing the caller to terminate early.
806 *never_interesting
= entry_not_interesting
;
809 if (pathlen
> matchlen
)
812 if (matchlen
> pathlen
) {
813 if (match
[pathlen
] != '/')
815 if (!S_ISDIR(entry
->mode
) && !S_ISGITLINK(entry
->mode
))
821 * we cheated and did not do strncmp(), so we do
824 m
= ps_strncmp(item
, match
, entry
->path
, pathlen
);
827 * If common part matched earlier then it is a hit,
828 * because we rejected the case where path is not a
829 * leading directory and is shorter than match.
833 * match_entry does not check if the prefix part is
834 * matched case-sensitively. If the entry is a
835 * directory and part of prefix, it'll be rematched
836 * eventually by basecmp with special treatment for
844 /* :(icase)-aware string compare */
845 static int basecmp(const struct pathspec_item
*item
,
846 const char *base
, const char *match
, int len
)
848 if (item
->magic
& PATHSPEC_ICASE
) {
849 int ret
, n
= len
> item
->prefix
? item
->prefix
: len
;
850 ret
= strncmp(base
, match
, n
);
857 return ps_strncmp(item
, base
, match
, len
);
860 static int match_dir_prefix(const struct pathspec_item
*item
,
862 const char *match
, int matchlen
)
864 if (basecmp(item
, base
, match
, matchlen
))
868 * If the base is a subdirectory of a path which
869 * was specified, all of them are interesting.
872 base
[matchlen
] == '/' ||
873 match
[matchlen
- 1] == '/')
876 /* Just a random prefix match */
881 * Perform matching on the leading non-wildcard part of
882 * pathspec. item->nowildcard_len must be greater than zero. Return
883 * non-zero if base is matched.
885 static int match_wildcard_base(const struct pathspec_item
*item
,
886 const char *base
, int baselen
,
889 const char *match
= item
->match
;
890 /* the wildcard part is not considered in this function */
891 int matchlen
= item
->nowildcard_len
;
896 * Return early if base is longer than the
897 * non-wildcard part but it does not match.
899 if (baselen
>= matchlen
) {
901 return !basecmp(item
, base
, match
, matchlen
);
905 while (dirlen
&& match
[dirlen
- 1] != '/')
909 * Return early if base is shorter than the
910 * non-wildcard part but it does not match. Note that
911 * base ends with '/' so we are sure it really matches
914 if (basecmp(item
, base
, match
, baselen
))
920 * we could have checked entry against the non-wildcard part
921 * that is not in base and does similar never_interesting
922 * optimization as in match_entry. For now just be happy with
925 return entry_interesting
;
929 * Is a tree entry interesting given the pathspec we have?
931 * Pre-condition: either baselen == base_offset (i.e. empty path)
932 * or base[baselen-1] == '/' (i.e. with trailing slash).
934 static enum interesting
do_match(const struct name_entry
*entry
,
935 struct strbuf
*base
, int base_offset
,
936 const struct pathspec
*ps
,
940 int pathlen
, baselen
= base
->len
- base_offset
;
941 enum interesting never_interesting
= ps
->has_wildcard
?
942 entry_not_interesting
: all_entries_not_interesting
;
953 if (!ps
->recursive
||
954 !(ps
->magic
& PATHSPEC_MAXDEPTH
) ||
956 return all_entries_interesting
;
957 return within_depth(base
->buf
+ base_offset
, baselen
,
958 !!S_ISDIR(entry
->mode
),
960 entry_interesting
: entry_not_interesting
;
963 pathlen
= tree_entry_len(entry
);
965 for (i
= ps
->nr
- 1; i
>= 0; i
--) {
966 const struct pathspec_item
*item
= ps
->items
+i
;
967 const char *match
= item
->match
;
968 const char *base_str
= base
->buf
+ base_offset
;
969 int matchlen
= item
->len
, matched
= 0;
971 if ((!exclude
&& item
->magic
& PATHSPEC_EXCLUDE
) ||
972 ( exclude
&& !(item
->magic
& PATHSPEC_EXCLUDE
)))
975 if (baselen
>= matchlen
) {
976 /* If it doesn't match, move along... */
977 if (!match_dir_prefix(item
, base_str
, match
, matchlen
))
978 goto match_wildcards
;
980 if (!ps
->recursive
||
981 !(ps
->magic
& PATHSPEC_MAXDEPTH
) ||
983 return all_entries_interesting
;
985 return within_depth(base_str
+ matchlen
+ 1,
986 baselen
- matchlen
- 1,
987 !!S_ISDIR(entry
->mode
),
989 entry_interesting
: entry_not_interesting
;
992 /* Either there must be no base, or the base must match. */
993 if (baselen
== 0 || !basecmp(item
, base_str
, match
, baselen
)) {
994 if (match_entry(item
, entry
, pathlen
,
995 match
+ baselen
, matchlen
- baselen
,
997 return entry_interesting
;
999 if (item
->nowildcard_len
< item
->len
) {
1000 if (!git_fnmatch(item
, match
+ baselen
, entry
->path
,
1001 item
->nowildcard_len
- baselen
))
1002 return entry_interesting
;
1005 * Match all directories. We'll try to
1006 * match files later on.
1008 if (ps
->recursive
&& S_ISDIR(entry
->mode
))
1009 return entry_interesting
;
1012 * When matching against submodules with
1013 * wildcard characters, ensure that the entry
1014 * at least matches up to the first wild
1015 * character. More accurate matching can then
1016 * be performed in the submodule itself.
1018 if (ps
->recurse_submodules
&&
1019 S_ISGITLINK(entry
->mode
) &&
1020 !ps_strncmp(item
, match
+ baselen
,
1022 item
->nowildcard_len
- baselen
))
1023 return entry_interesting
;
1030 if (item
->nowildcard_len
== item
->len
)
1033 if (item
->nowildcard_len
&&
1034 !match_wildcard_base(item
, base_str
, baselen
, &matched
))
1038 * Concatenate base and entry->path into one and do
1041 * While we could avoid concatenation in certain cases
1042 * [1], which saves a memcpy and potentially a
1043 * realloc, it turns out not worth it. Measurement on
1044 * linux-2.6 does not show any clear improvements,
1045 * partly because of the nowildcard_len optimization
1046 * in git_fnmatch(). Avoid micro-optimizations here.
1048 * [1] if match_wildcard_base() says the base
1049 * directory is already matched, we only need to match
1050 * the rest, which is shorter so _in theory_ faster.
1053 strbuf_add(base
, entry
->path
, pathlen
);
1055 if (!git_fnmatch(item
, match
, base
->buf
+ base_offset
,
1056 item
->nowildcard_len
)) {
1057 strbuf_setlen(base
, base_offset
+ baselen
);
1058 return entry_interesting
;
1062 * When matching against submodules with
1063 * wildcard characters, ensure that the entry
1064 * at least matches up to the first wild
1065 * character. More accurate matching can then
1066 * be performed in the submodule itself.
1068 if (ps
->recurse_submodules
&& S_ISGITLINK(entry
->mode
) &&
1069 !ps_strncmp(item
, match
, base
->buf
+ base_offset
,
1070 item
->nowildcard_len
)) {
1071 strbuf_setlen(base
, base_offset
+ baselen
);
1072 return entry_interesting
;
1075 strbuf_setlen(base
, base_offset
+ baselen
);
1078 * Match all directories. We'll try to match files
1080 * max_depth is ignored but we may consider support it
1082 * https://public-inbox.org/git/7vmxo5l2g4.fsf@alter.siamese.dyndns.org/
1084 if (ps
->recursive
&& S_ISDIR(entry
->mode
))
1085 return entry_interesting
;
1087 return never_interesting
; /* No matches */
1091 * Is a tree entry interesting given the pathspec we have?
1093 * Pre-condition: either baselen == base_offset (i.e. empty path)
1094 * or base[baselen-1] == '/' (i.e. with trailing slash).
1096 enum interesting
tree_entry_interesting(const struct name_entry
*entry
,
1097 struct strbuf
*base
, int base_offset
,
1098 const struct pathspec
*ps
)
1100 enum interesting positive
, negative
;
1101 positive
= do_match(entry
, base
, base_offset
, ps
, 0);
1104 * case | entry | positive | negative | result
1105 * -----+-------+----------+----------+-------
1106 * 1 | file | -1 | -1..2 | -1
1107 * 2 | file | 0 | -1..2 | 0
1108 * 3 | file | 1 | -1 | 1
1109 * 4 | file | 1 | 0 | 1
1110 * 5 | file | 1 | 1 | 0
1111 * 6 | file | 1 | 2 | 0
1112 * 7 | file | 2 | -1 | 2
1113 * 8 | file | 2 | 0 | 1
1114 * 9 | file | 2 | 1 | 0
1115 * 10 | file | 2 | 2 | -1
1116 * -----+-------+----------+----------+-------
1117 * 11 | dir | -1 | -1..2 | -1
1118 * 12 | dir | 0 | -1..2 | 0
1119 * 13 | dir | 1 | -1 | 1
1120 * 14 | dir | 1 | 0 | 1
1121 * 15 | dir | 1 | 1 | 1 (*)
1122 * 16 | dir | 1 | 2 | 0
1123 * 17 | dir | 2 | -1 | 2
1124 * 18 | dir | 2 | 0 | 1
1125 * 19 | dir | 2 | 1 | 1 (*)
1126 * 20 | dir | 2 | 2 | -1
1128 * (*) An exclude pattern interested in a directory does not
1129 * necessarily mean it will exclude all of the directory. In
1130 * wildcard case, it can't decide until looking at individual
1131 * files inside. So don't write such directories off yet.
1134 if (!(ps
->magic
& PATHSPEC_EXCLUDE
) ||
1135 positive
<= entry_not_interesting
) /* #1, #2, #11, #12 */
1138 negative
= do_match(entry
, base
, base_offset
, ps
, 1);
1141 if (positive
== all_entries_interesting
&&
1142 negative
== entry_not_interesting
)
1143 return entry_interesting
;
1145 /* #3, #4, #7, #13, #14, #17 */
1146 if (negative
<= entry_not_interesting
)
1150 if (S_ISDIR(entry
->mode
) &&
1151 positive
>= entry_interesting
&&
1152 negative
== entry_interesting
)
1153 return entry_interesting
;
1155 if ((positive
== entry_interesting
&&
1156 negative
>= entry_interesting
) || /* #5, #6, #16 */
1157 (positive
== all_entries_interesting
&&
1158 negative
== entry_interesting
)) /* #9 */
1159 return entry_not_interesting
;
1161 return all_entries_not_interesting
; /* #10, #20 */