7 #include "object-store.h"
10 #include "json-writer.h"
12 static const char *get_mode(const char *str
, unsigned int *modep
)
15 unsigned int mode
= 0;
20 while ((c
= *str
++) != ' ') {
21 if (c
< '0' || c
> '7')
23 mode
= (mode
<< 3) + (c
- '0');
29 static int decode_tree_entry(struct tree_desc
*desc
, const char *buf
, unsigned long size
, struct strbuf
*err
)
32 unsigned int mode
, len
;
33 const unsigned hashsz
= the_hash_algo
->rawsz
;
35 if (size
< hashsz
+ 3 || buf
[size
- (hashsz
+ 1)]) {
36 strbuf_addstr(err
, _("too-short tree object"));
40 path
= get_mode(buf
, &mode
);
42 strbuf_addstr(err
, _("malformed mode in tree entry"));
46 strbuf_addstr(err
, _("empty filename in tree entry"));
49 len
= strlen(path
) + 1;
51 /* Initialize the descriptor entry */
52 desc
->entry
.path
= path
;
53 desc
->entry
.mode
= (desc
->flags
& TREE_DESC_RAW_MODES
) ? mode
: canon_mode(mode
);
54 desc
->entry
.pathlen
= len
- 1;
55 oidread(&desc
->entry
.oid
, (const unsigned char *)path
+ len
);
60 static int init_tree_desc_internal(struct tree_desc
*desc
, const void *buffer
,
61 unsigned long size
, struct strbuf
*err
,
62 enum tree_desc_flags flags
)
64 desc
->buffer
= buffer
;
68 return decode_tree_entry(desc
, buffer
, size
, err
);
72 void init_tree_desc(struct tree_desc
*desc
, const void *buffer
, unsigned long size
)
74 struct strbuf err
= STRBUF_INIT
;
75 if (init_tree_desc_internal(desc
, buffer
, size
, &err
, 0))
80 int init_tree_desc_gently(struct tree_desc
*desc
, const void *buffer
, unsigned long size
,
81 enum tree_desc_flags flags
)
83 struct strbuf err
= STRBUF_INIT
;
84 int result
= init_tree_desc_internal(desc
, buffer
, size
, &err
, flags
);
91 void *fill_tree_descriptor(struct repository
*r
,
92 struct tree_desc
*desc
,
93 const struct object_id
*oid
)
95 unsigned long size
= 0;
99 buf
= read_object_with_reference(r
, oid
, OBJ_TREE
, &size
, NULL
);
101 die("unable to read tree %s", oid_to_hex(oid
));
103 init_tree_desc(desc
, buf
, size
);
107 static void entry_clear(struct name_entry
*a
)
109 memset(a
, 0, sizeof(*a
));
112 static void entry_extract(struct tree_desc
*t
, struct name_entry
*a
)
117 static int update_tree_entry_internal(struct tree_desc
*desc
, struct strbuf
*err
)
119 const void *buf
= desc
->buffer
;
120 const unsigned char *end
= (const unsigned char *)desc
->entry
.path
+ desc
->entry
.pathlen
+ 1 + the_hash_algo
->rawsz
;
121 unsigned long size
= desc
->size
;
122 unsigned long len
= end
- (const unsigned char *)buf
;
125 die(_("too-short tree file"));
131 return decode_tree_entry(desc
, buf
, size
, err
);
135 void update_tree_entry(struct tree_desc
*desc
)
137 struct strbuf err
= STRBUF_INIT
;
138 if (update_tree_entry_internal(desc
, &err
))
140 strbuf_release(&err
);
143 int update_tree_entry_gently(struct tree_desc
*desc
)
145 struct strbuf err
= STRBUF_INIT
;
146 if (update_tree_entry_internal(desc
, &err
)) {
147 error("%s", err
.buf
);
148 strbuf_release(&err
);
149 /* Stop processing this tree after error */
153 strbuf_release(&err
);
157 int tree_entry(struct tree_desc
*desc
, struct name_entry
*entry
)
162 *entry
= desc
->entry
;
163 update_tree_entry(desc
);
167 int tree_entry_gently(struct tree_desc
*desc
, struct name_entry
*entry
)
172 *entry
= desc
->entry
;
173 if (update_tree_entry_gently(desc
))
178 static int traverse_trees_atexit_registered
;
179 static int traverse_trees_count
;
180 static int traverse_trees_cur_depth
;
181 static int traverse_trees_max_depth
;
183 static void trace2_traverse_trees_statistics_atexit(void)
185 struct json_writer jw
= JSON_WRITER_INIT
;
187 jw_object_begin(&jw
, 0);
188 jw_object_intmax(&jw
, "traverse_trees_count", traverse_trees_count
);
189 jw_object_intmax(&jw
, "traverse_trees_max_depth", traverse_trees_max_depth
);
192 trace2_data_json("traverse_trees", the_repository
, "statistics", &jw
);
197 void setup_traverse_info(struct traverse_info
*info
, const char *base
)
199 size_t pathlen
= strlen(base
);
200 static struct traverse_info dummy
;
202 memset(info
, 0, sizeof(*info
));
203 if (pathlen
&& base
[pathlen
-1] == '/')
205 info
->pathlen
= pathlen
? pathlen
+ 1 : 0;
207 info
->namelen
= pathlen
;
211 if (trace2_is_enabled() && !traverse_trees_atexit_registered
) {
212 atexit(trace2_traverse_trees_statistics_atexit
);
213 traverse_trees_atexit_registered
= 1;
217 char *make_traverse_path(char *path
, size_t pathlen
,
218 const struct traverse_info
*info
,
219 const char *name
, size_t namelen
)
221 /* Always points to the end of the name we're about to add */
222 size_t pos
= st_add(info
->pathlen
, namelen
);
225 BUG("too small buffer passed to make_traverse_path");
230 BUG("traverse_info pathlen does not match strings");
232 memcpy(path
+ pos
, name
, namelen
);
239 BUG("traverse_info ran out of list items");
241 namelen
= info
->namelen
;
247 void strbuf_make_traverse_path(struct strbuf
*out
,
248 const struct traverse_info
*info
,
249 const char *name
, size_t namelen
)
251 size_t len
= traverse_path_len(info
, namelen
);
253 strbuf_grow(out
, len
);
254 make_traverse_path(out
->buf
+ out
->len
, out
->alloc
- out
->len
,
255 info
, name
, namelen
);
256 strbuf_setlen(out
, out
->len
+ len
);
259 struct tree_desc_skip
{
260 struct tree_desc_skip
*prev
;
266 struct tree_desc_skip
*skip
;
269 static int check_entry_match(const char *a
, int a_len
, const char *b
, int b_len
)
272 * The caller wants to pick *a* from a tree or nothing.
273 * We are looking at *b* in a tree.
275 * (0) If a and b are the same name, we are trivially happy.
277 * There are three possibilities where *a* could be hiding
280 * (1) *a* == "t", *b* == "ab" i.e. *b* sorts earlier than *a* no
282 * (2) *a* == "t", *b* == "t-2" and "t" is a subtree in the tree;
283 * (3) *a* == "t-2", *b* == "t" and "t-2" is a blob in the tree.
285 * Otherwise we know *a* won't appear in the tree without
289 int cmp
= name_compare(a
, a_len
, b
, b_len
);
291 /* Most common case first -- reading sync'd trees */
296 /* a comes after b; it does not matter if it is case (3)
297 if (b_len < a_len && !memcmp(a, b, b_len) && a[b_len] < '/')
300 return 1; /* keep looking */
303 /* b comes after a; are we looking at case (2)? */
304 if (a_len
< b_len
&& !memcmp(a
, b
, a_len
) && b
[a_len
] < '/')
305 return 1; /* keep looking */
307 return -1; /* a cannot appear in the tree */
311 * From the extended tree_desc, extract the first name entry, while
312 * paying attention to the candidate "first" name. Most importantly,
313 * when looking for an entry, if there are entries that sorts earlier
314 * in the tree object representation than that name, skip them and
315 * process the named entry first. We will remember that we haven't
316 * processed the first entry yet, and in the later call skip the
317 * entry we processed early when update_extended_entry() is called.
319 * E.g. if the underlying tree object has these entries:
326 * and the "first" asks for "t", remember that we still need to
327 * process "t-1" and "t-2" but extract "t". After processing the
328 * entry "t" from this call, the caller will let us know by calling
329 * update_extended_entry() that we can remember "t" has been processed
333 static void extended_entry_extract(struct tree_desc_x
*t
,
334 struct name_entry
*a
,
340 struct tree_desc probe
;
341 struct tree_desc_skip
*skip
;
344 * Extract the first entry from the tree_desc, but skip the
345 * ones that we already returned in earlier rounds.
350 break; /* not found */
352 entry_extract(&t
->d
, a
);
353 for (skip
= t
->skip
; skip
; skip
= skip
->prev
)
354 if (a
->path
== skip
->ptr
)
358 /* We have processed this entry already. */
359 update_tree_entry(&t
->d
);
362 if (!first
|| !a
->path
)
366 * The caller wants "first" from this tree, or nothing.
369 len
= tree_entry_len(a
);
370 switch (check_entry_match(first
, first_len
, path
, len
)) {
380 * We need to look-ahead -- we suspect that a subtree whose
381 * name is "first" may be hiding behind the current entry "path".
385 entry_extract(&probe
, a
);
387 len
= tree_entry_len(a
);
388 switch (check_entry_match(first
, first_len
, path
, len
)) {
394 update_tree_entry(&probe
);
402 static void update_extended_entry(struct tree_desc_x
*t
, struct name_entry
*a
)
404 if (t
->d
.entry
.path
== a
->path
) {
405 update_tree_entry(&t
->d
);
407 /* we have returned this entry early */
408 struct tree_desc_skip
*skip
= xmalloc(sizeof(*skip
));
410 skip
->prev
= t
->skip
;
415 static void free_extended_entry(struct tree_desc_x
*t
)
417 struct tree_desc_skip
*p
, *s
;
419 for (s
= t
->skip
; s
; s
= p
) {
425 static inline int prune_traversal(struct index_state
*istate
,
426 struct name_entry
*e
,
427 struct traverse_info
*info
,
429 int still_interesting
)
431 if (!info
->pathspec
|| still_interesting
== 2)
433 if (still_interesting
< 0)
434 return still_interesting
;
435 return tree_entry_interesting(istate
, e
, base
,
439 int traverse_trees(struct index_state
*istate
,
440 int n
, struct tree_desc
*t
,
441 struct traverse_info
*info
)
444 struct name_entry entry
[MAX_TRAVERSE_TREES
];
446 struct tree_desc_x tx
[ARRAY_SIZE(entry
)];
447 struct strbuf base
= STRBUF_INIT
;
451 traverse_trees_count
++;
452 traverse_trees_cur_depth
++;
454 if (traverse_trees_cur_depth
> traverse_trees_max_depth
)
455 traverse_trees_max_depth
= traverse_trees_cur_depth
;
457 if (n
>= ARRAY_SIZE(entry
))
458 BUG("traverse_trees() called with too many trees (%d)", n
);
460 for (i
= 0; i
< n
; i
++) {
466 strbuf_make_traverse_path(&base
, info
->prev
,
467 info
->name
, info
->namelen
);
468 strbuf_addch(&base
, '/');
469 traverse_path
= xstrndup(base
.buf
, base
.len
);
471 traverse_path
= xstrndup(info
->name
, info
->pathlen
);
473 info
->traverse_path
= traverse_path
;
476 unsigned long mask
, dirmask
;
477 const char *first
= NULL
;
479 struct name_entry
*e
= NULL
;
482 for (i
= 0; i
< n
; i
++) {
484 extended_entry_extract(tx
+ i
, e
, NULL
, 0);
488 * A tree may have "t-2" at the current location even
489 * though it may have "t" that is a subtree behind it,
490 * and another tree may return "t". We want to grab
491 * all "t" from all trees to match in such a case.
493 for (i
= 0; i
< n
; i
++) {
497 len
= tree_entry_len(e
);
503 if (name_compare(e
->path
, len
, first
, first_len
) < 0) {
510 for (i
= 0; i
< n
; i
++) {
512 extended_entry_extract(tx
+ i
, e
, first
, first_len
);
513 /* Cull the ones that are not the earliest */
516 len
= tree_entry_len(e
);
517 if (name_compare(e
->path
, len
, first
, first_len
))
522 /* Now we have in entry[i] the earliest name from the trees */
525 for (i
= 0; i
< n
; i
++) {
529 if (S_ISDIR(entry
[i
].mode
))
535 interesting
= prune_traversal(istate
, e
, info
, &base
, interesting
);
539 trees_used
= info
->fn(n
, mask
, dirmask
, entry
, info
);
540 if (trees_used
< 0) {
542 if (!info
->show_all_errors
)
547 for (i
= 0; i
< n
; i
++)
548 if (mask
& (1ul << i
))
549 update_extended_entry(tx
+ i
, entry
+ i
);
551 for (i
= 0; i
< n
; i
++)
552 free_extended_entry(tx
+ i
);
554 info
->traverse_path
= NULL
;
555 strbuf_release(&base
);
557 traverse_trees_cur_depth
--;
564 struct object_id oid
;
567 static int find_tree_entry(struct repository
*r
, struct tree_desc
*t
,
568 const char *name
, struct object_id
*result
,
569 unsigned short *mode
)
571 int namelen
= strlen(name
);
574 struct object_id oid
;
577 oidcpy(&oid
, tree_entry_extract(t
, &entry
, mode
));
578 entrylen
= tree_entry_len(&t
->entry
);
579 update_tree_entry(t
);
580 if (entrylen
> namelen
)
582 cmp
= memcmp(name
, entry
, entrylen
);
587 if (entrylen
== namelen
) {
588 oidcpy(result
, &oid
);
591 if (name
[entrylen
] != '/')
595 if (++entrylen
== namelen
) {
596 oidcpy(result
, &oid
);
599 return get_tree_entry(r
, &oid
, name
+ entrylen
, result
, mode
);
604 int get_tree_entry(struct repository
*r
,
605 const struct object_id
*tree_oid
,
607 struct object_id
*oid
,
608 unsigned short *mode
)
613 struct object_id root
;
615 tree
= read_object_with_reference(r
, tree_oid
, OBJ_TREE
, &size
, &root
);
619 if (name
[0] == '\0') {
629 init_tree_desc(&t
, tree
, size
);
630 retval
= find_tree_entry(r
, &t
, name
, oid
, mode
);
637 * This is Linux's built-in max for the number of symlinks to follow.
638 * That limit, of course, does not affect git, but it's a reasonable
641 #define GET_TREE_ENTRY_FOLLOW_SYMLINKS_MAX_LINKS 40
644 * Find a tree entry by following symlinks in tree_sha (which is
645 * assumed to be the root of the repository). In the event that a
646 * symlink points outside the repository (e.g. a link to /foo or a
647 * root-level link to ../foo), the portion of the link which is
648 * outside the repository will be returned in result_path, and *mode
649 * will be set to 0. It is assumed that result_path is uninitialized.
650 * If there are no symlinks, or the end result of the symlink chain
651 * points to an object inside the repository, result will be filled in
652 * with the sha1 of the found object, and *mode will hold the mode of
655 * See the code for enum get_oid_result for a description of
658 enum get_oid_result
get_tree_entry_follow_symlinks(struct repository
*r
,
659 struct object_id
*tree_oid
, const char *name
,
660 struct object_id
*result
, struct strbuf
*result_path
,
661 unsigned short *mode
)
663 int retval
= MISSING_OBJECT
;
664 struct dir_state
*parents
= NULL
;
665 size_t parents_alloc
= 0;
666 size_t i
, parents_nr
= 0;
667 struct object_id current_tree_oid
;
668 struct strbuf namebuf
= STRBUF_INIT
;
670 int follows_remaining
= GET_TREE_ENTRY_FOLLOW_SYMLINKS_MAX_LINKS
;
672 init_tree_desc(&t
, NULL
, 0UL);
673 strbuf_addstr(&namebuf
, name
);
674 oidcpy(¤t_tree_oid
, tree_oid
);
679 char *remainder
= NULL
;
683 struct object_id root
;
685 tree
= read_object_with_reference(r
,
692 ALLOC_GROW(parents
, parents_nr
+ 1, parents_alloc
);
693 parents
[parents_nr
].tree
= tree
;
694 parents
[parents_nr
].size
= size
;
695 oidcpy(&parents
[parents_nr
].oid
, &root
);
698 if (namebuf
.buf
[0] == '\0') {
699 oidcpy(result
, &root
);
708 init_tree_desc(&t
, tree
, size
);
711 /* Handle symlinks to e.g. a//b by removing leading slashes */
712 while (namebuf
.buf
[0] == '/') {
713 strbuf_remove(&namebuf
, 0, 1);
716 /* Split namebuf into a first component and a remainder */
717 if ((first_slash
= strchr(namebuf
.buf
, '/'))) {
719 remainder
= first_slash
+ 1;
722 if (!strcmp(namebuf
.buf
, "..")) {
723 struct dir_state
*parent
;
725 * We could end up with .. in the namebuf if it
726 * appears in a symlink.
729 if (parents_nr
== 1) {
732 strbuf_add(result_path
, namebuf
.buf
,
738 parent
= &parents
[parents_nr
- 1];
741 parent
= &parents
[parents_nr
- 1];
742 init_tree_desc(&t
, parent
->tree
, parent
->size
);
743 strbuf_remove(&namebuf
, 0, remainder
? 3 : 2);
747 /* We could end up here via a symlink to dir/.. */
748 if (namebuf
.buf
[0] == '\0') {
749 oidcpy(result
, &parents
[parents_nr
- 1].oid
);
754 /* Look up the first (or only) path component in the tree. */
755 find_result
= find_tree_entry(r
, &t
, namebuf
.buf
,
756 ¤t_tree_oid
, mode
);
761 if (S_ISDIR(*mode
)) {
763 oidcpy(result
, ¤t_tree_oid
);
767 /* Descend the tree */
769 strbuf_remove(&namebuf
, 0,
770 1 + first_slash
- namebuf
.buf
);
771 } else if (S_ISREG(*mode
)) {
773 oidcpy(result
, ¤t_tree_oid
);
779 } else if (S_ISLNK(*mode
)) {
780 /* Follow a symlink */
781 unsigned long link_len
;
783 char *contents
, *contents_start
;
784 struct dir_state
*parent
;
785 enum object_type type
;
787 if (follows_remaining
-- == 0) {
788 /* Too many symlinks followed */
789 retval
= SYMLINK_LOOP
;
794 * At this point, we have followed at a least
795 * one symlink, so on error we need to report this.
797 retval
= DANGLING_SYMLINK
;
799 contents
= repo_read_object_file(r
,
800 ¤t_tree_oid
, &type
,
806 if (contents
[0] == '/') {
807 strbuf_addstr(result_path
, contents
);
815 len
= first_slash
- namebuf
.buf
;
819 contents_start
= contents
;
821 parent
= &parents
[parents_nr
- 1];
822 init_tree_desc(&t
, parent
->tree
, parent
->size
);
823 strbuf_splice(&namebuf
, 0, len
,
824 contents_start
, link_len
);
826 namebuf
.buf
[link_len
] = '/';
831 for (i
= 0; i
< parents_nr
; i
++)
832 free(parents
[i
].tree
);
835 strbuf_release(&namebuf
);
839 static int match_entry(const struct pathspec_item
*item
,
840 const struct name_entry
*entry
, int pathlen
,
841 const char *match
, int matchlen
,
842 enum interesting
*never_interesting
)
844 int m
= -1; /* signals that we haven't called strncmp() */
846 if (item
->magic
& PATHSPEC_ICASE
)
848 * "Never interesting" trick requires exact
849 * matching. We could do something clever with inexact
850 * matching, but it's trickier (and not to forget that
851 * strcasecmp is locale-dependent, at least in
852 * glibc). Just disable it for now. It can't be worse
853 * than the wildcard's codepath of '[Tt][Hi][Is][Ss]'
856 *never_interesting
= entry_not_interesting
;
857 else if (*never_interesting
!= entry_not_interesting
) {
859 * We have not seen any match that sorts later
860 * than the current path.
864 * Does match sort strictly earlier than path
865 * with their common parts?
867 m
= strncmp(match
, entry
->path
,
868 (matchlen
< pathlen
) ? matchlen
: pathlen
);
873 * If we come here even once, that means there is at
874 * least one pathspec that would sort equal to or
875 * later than the path we are currently looking at.
876 * In other words, if we have never reached this point
877 * after iterating all pathspecs, it means all
878 * pathspecs are either outside of base, or inside the
879 * base but sorts strictly earlier than the current
880 * one. In either case, they will never match the
881 * subsequent entries. In such a case, we initialized
882 * the variable to -1 and that is what will be
883 * returned, allowing the caller to terminate early.
885 *never_interesting
= entry_not_interesting
;
888 if (pathlen
> matchlen
)
891 if (matchlen
> pathlen
) {
892 if (match
[pathlen
] != '/')
895 * Reject non-directories as partial pathnames, except
896 * when match is a submodule with a trailing slash and
897 * nothing else (to handle 'submod/' and 'submod'
900 if (!S_ISDIR(entry
->mode
) &&
901 (!S_ISGITLINK(entry
->mode
) || matchlen
> pathlen
+ 1))
907 * we cheated and did not do strncmp(), so we do
910 m
= ps_strncmp(item
, match
, entry
->path
, pathlen
);
913 * If common part matched earlier then it is a hit,
914 * because we rejected the case where path is not a
915 * leading directory and is shorter than match.
919 * match_entry does not check if the prefix part is
920 * matched case-sensitively. If the entry is a
921 * directory and part of prefix, it'll be rematched
922 * eventually by basecmp with special treatment for
930 /* :(icase)-aware string compare */
931 static int basecmp(const struct pathspec_item
*item
,
932 const char *base
, const char *match
, int len
)
934 if (item
->magic
& PATHSPEC_ICASE
) {
935 int ret
, n
= len
> item
->prefix
? item
->prefix
: len
;
936 ret
= strncmp(base
, match
, n
);
943 return ps_strncmp(item
, base
, match
, len
);
946 static int match_dir_prefix(const struct pathspec_item
*item
,
948 const char *match
, int matchlen
)
950 if (basecmp(item
, base
, match
, matchlen
))
954 * If the base is a subdirectory of a path which
955 * was specified, all of them are interesting.
958 base
[matchlen
] == '/' ||
959 match
[matchlen
- 1] == '/')
962 /* Just a random prefix match */
967 * Perform matching on the leading non-wildcard part of
968 * pathspec. item->nowildcard_len must be greater than zero. Return
969 * non-zero if base is matched.
971 static int match_wildcard_base(const struct pathspec_item
*item
,
972 const char *base
, int baselen
,
975 const char *match
= item
->match
;
976 /* the wildcard part is not considered in this function */
977 int matchlen
= item
->nowildcard_len
;
982 * Return early if base is longer than the
983 * non-wildcard part but it does not match.
985 if (baselen
>= matchlen
) {
987 return !basecmp(item
, base
, match
, matchlen
);
991 while (dirlen
&& match
[dirlen
- 1] != '/')
995 * Return early if base is shorter than the
996 * non-wildcard part but it does not match. Note that
997 * base ends with '/' so we are sure it really matches
1000 if (basecmp(item
, base
, match
, baselen
))
1006 * we could have checked entry against the non-wildcard part
1007 * that is not in base and does similar never_interesting
1008 * optimization as in match_entry. For now just be happy with
1011 return entry_interesting
;
1015 * Is a tree entry interesting given the pathspec we have?
1017 * Pre-condition: either baselen == base_offset (i.e. empty path)
1018 * or base[baselen-1] == '/' (i.e. with trailing slash).
1020 static enum interesting
do_match(struct index_state
*istate
,
1021 const struct name_entry
*entry
,
1022 struct strbuf
*base
, int base_offset
,
1023 const struct pathspec
*ps
,
1027 int pathlen
, baselen
= base
->len
- base_offset
;
1028 enum interesting never_interesting
= ps
->has_wildcard
?
1029 entry_not_interesting
: all_entries_not_interesting
;
1041 if (!ps
->recursive
||
1042 !(ps
->magic
& PATHSPEC_MAXDEPTH
) ||
1043 ps
->max_depth
== -1)
1044 return all_entries_interesting
;
1045 return within_depth(base
->buf
+ base_offset
, baselen
,
1046 !!S_ISDIR(entry
->mode
),
1048 entry_interesting
: entry_not_interesting
;
1051 pathlen
= tree_entry_len(entry
);
1053 for (i
= ps
->nr
- 1; i
>= 0; i
--) {
1054 const struct pathspec_item
*item
= ps
->items
+i
;
1055 const char *match
= item
->match
;
1056 const char *base_str
= base
->buf
+ base_offset
;
1057 int matchlen
= item
->len
, matched
= 0;
1059 if ((!exclude
&& item
->magic
& PATHSPEC_EXCLUDE
) ||
1060 ( exclude
&& !(item
->magic
& PATHSPEC_EXCLUDE
)))
1063 if (baselen
>= matchlen
) {
1064 /* If it doesn't match, move along... */
1065 if (!match_dir_prefix(item
, base_str
, match
, matchlen
))
1066 goto match_wildcards
;
1068 if (!ps
->recursive
||
1069 !(ps
->magic
& PATHSPEC_MAXDEPTH
) ||
1070 ps
->max_depth
== -1) {
1071 if (!item
->attr_match_nr
)
1072 return all_entries_interesting
;
1077 if (within_depth(base_str
+ matchlen
+ 1,
1078 baselen
- matchlen
- 1,
1079 !!S_ISDIR(entry
->mode
),
1083 return entry_not_interesting
;
1086 /* Either there must be no base, or the base must match. */
1087 if (baselen
== 0 || !basecmp(item
, base_str
, match
, baselen
)) {
1088 if (match_entry(item
, entry
, pathlen
,
1089 match
+ baselen
, matchlen
- baselen
,
1090 &never_interesting
))
1093 if (item
->nowildcard_len
< item
->len
) {
1094 if (!git_fnmatch(item
, match
+ baselen
, entry
->path
,
1095 item
->nowildcard_len
- baselen
))
1099 * Match all directories. We'll try to
1100 * match files later on.
1102 if (ps
->recursive
&& S_ISDIR(entry
->mode
))
1103 return entry_interesting
;
1106 * When matching against submodules with
1107 * wildcard characters, ensure that the entry
1108 * at least matches up to the first wild
1109 * character. More accurate matching can then
1110 * be performed in the submodule itself.
1112 if (ps
->recurse_submodules
&&
1113 S_ISGITLINK(entry
->mode
) &&
1114 !ps_strncmp(item
, match
+ baselen
,
1116 item
->nowildcard_len
- baselen
))
1124 if (item
->nowildcard_len
== item
->len
)
1127 if (item
->nowildcard_len
&&
1128 !match_wildcard_base(item
, base_str
, baselen
, &matched
))
1132 * Concatenate base and entry->path into one and do
1135 * While we could avoid concatenation in certain cases
1136 * [1], which saves a memcpy and potentially a
1137 * realloc, it turns out not worth it. Measurement on
1138 * linux-2.6 does not show any clear improvements,
1139 * partly because of the nowildcard_len optimization
1140 * in git_fnmatch(). Avoid micro-optimizations here.
1142 * [1] if match_wildcard_base() says the base
1143 * directory is already matched, we only need to match
1144 * the rest, which is shorter so _in theory_ faster.
1147 strbuf_add(base
, entry
->path
, pathlen
);
1149 if (!git_fnmatch(item
, match
, base
->buf
+ base_offset
,
1150 item
->nowildcard_len
)) {
1151 strbuf_setlen(base
, base_offset
+ baselen
);
1156 * When matching against submodules with
1157 * wildcard characters, ensure that the entry
1158 * at least matches up to the first wild
1159 * character. More accurate matching can then
1160 * be performed in the submodule itself.
1162 if (ps
->recurse_submodules
&& S_ISGITLINK(entry
->mode
) &&
1163 !ps_strncmp(item
, match
, base
->buf
+ base_offset
,
1164 item
->nowildcard_len
)) {
1165 strbuf_setlen(base
, base_offset
+ baselen
);
1169 strbuf_setlen(base
, base_offset
+ baselen
);
1172 * Match all directories. We'll try to match files
1174 * max_depth is ignored but we may consider support it
1176 * https://lore.kernel.org/git/7vmxo5l2g4.fsf@alter.siamese.dyndns.org/
1178 if (ps
->recursive
&& S_ISDIR(entry
->mode
))
1179 return entry_interesting
;
1182 if (item
->attr_match_nr
) {
1186 * Must not return all_entries_not_interesting
1187 * prematurely. We do not know if all entries do not
1188 * match some attributes with current attr API.
1190 never_interesting
= entry_not_interesting
;
1193 * Consider all directories interesting (because some
1194 * of those files inside may match some attributes
1195 * even though the parent dir does not)
1197 * FIXME: attributes _can_ match directories and we
1198 * can probably return all_entries_interesting or
1199 * all_entries_not_interesting here if matched.
1201 if (S_ISDIR(entry
->mode
))
1202 return entry_interesting
;
1204 strbuf_add(base
, entry
->path
, pathlen
);
1205 ret
= match_pathspec_attrs(istate
, base
->buf
+ base_offset
,
1206 base
->len
- base_offset
, item
);
1207 strbuf_setlen(base
, base_offset
+ baselen
);
1211 return entry_interesting
;
1213 return never_interesting
; /* No matches */
1217 * Is a tree entry interesting given the pathspec we have?
1219 * Pre-condition: either baselen == base_offset (i.e. empty path)
1220 * or base[baselen-1] == '/' (i.e. with trailing slash).
1222 enum interesting
tree_entry_interesting(struct index_state
*istate
,
1223 const struct name_entry
*entry
,
1224 struct strbuf
*base
, int base_offset
,
1225 const struct pathspec
*ps
)
1227 enum interesting positive
, negative
;
1228 positive
= do_match(istate
, entry
, base
, base_offset
, ps
, 0);
1231 * case | entry | positive | negative | result
1232 * -----+-------+----------+----------+-------
1233 * 1 | file | -1 | -1..2 | -1
1234 * 2 | file | 0 | -1..2 | 0
1235 * 3 | file | 1 | -1 | 1
1236 * 4 | file | 1 | 0 | 1
1237 * 5 | file | 1 | 1 | 0
1238 * 6 | file | 1 | 2 | 0
1239 * 7 | file | 2 | -1 | 2
1240 * 8 | file | 2 | 0 | 1
1241 * 9 | file | 2 | 1 | 0
1242 * 10 | file | 2 | 2 | -1
1243 * -----+-------+----------+----------+-------
1244 * 11 | dir | -1 | -1..2 | -1
1245 * 12 | dir | 0 | -1..2 | 0
1246 * 13 | dir | 1 | -1 | 1
1247 * 14 | dir | 1 | 0 | 1
1248 * 15 | dir | 1 | 1 | 1 (*)
1249 * 16 | dir | 1 | 2 | 0
1250 * 17 | dir | 2 | -1 | 2
1251 * 18 | dir | 2 | 0 | 1
1252 * 19 | dir | 2 | 1 | 1 (*)
1253 * 20 | dir | 2 | 2 | -1
1255 * (*) An exclude pattern interested in a directory does not
1256 * necessarily mean it will exclude all of the directory. In
1257 * wildcard case, it can't decide until looking at individual
1258 * files inside. So don't write such directories off yet.
1261 if (!(ps
->magic
& PATHSPEC_EXCLUDE
) ||
1262 positive
<= entry_not_interesting
) /* #1, #2, #11, #12 */
1265 negative
= do_match(istate
, entry
, base
, base_offset
, ps
, 1);
1268 if (positive
== all_entries_interesting
&&
1269 negative
== entry_not_interesting
)
1270 return entry_interesting
;
1272 /* #3, #4, #7, #13, #14, #17 */
1273 if (negative
<= entry_not_interesting
)
1277 if (S_ISDIR(entry
->mode
) &&
1278 positive
>= entry_interesting
&&
1279 negative
== entry_interesting
)
1280 return entry_interesting
;
1282 if ((positive
== entry_interesting
&&
1283 negative
>= entry_interesting
) || /* #5, #6, #16 */
1284 (positive
== all_entries_interesting
&&
1285 negative
== entry_interesting
)) /* #9 */
1286 return entry_not_interesting
;
1288 return all_entries_not_interesting
; /* #10, #20 */