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 repository
*r
,
85 struct tree_desc
*desc
,
86 const struct object_id
*oid
)
88 unsigned long size
= 0;
92 buf
= read_object_with_reference(r
, oid
, tree_type
, &size
, NULL
);
94 die("unable to read tree %s", oid_to_hex(oid
));
96 init_tree_desc(desc
, buf
, size
);
100 static void entry_clear(struct name_entry
*a
)
102 memset(a
, 0, sizeof(*a
));
105 static void entry_extract(struct tree_desc
*t
, struct name_entry
*a
)
110 static int update_tree_entry_internal(struct tree_desc
*desc
, struct strbuf
*err
)
112 const void *buf
= desc
->buffer
;
113 const unsigned char *end
= (const unsigned char *)desc
->entry
.path
+ desc
->entry
.pathlen
+ 1 + the_hash_algo
->rawsz
;
114 unsigned long size
= desc
->size
;
115 unsigned long len
= end
- (const unsigned char *)buf
;
118 die(_("too-short tree file"));
124 return decode_tree_entry(desc
, buf
, size
, err
);
128 void update_tree_entry(struct tree_desc
*desc
)
130 struct strbuf err
= STRBUF_INIT
;
131 if (update_tree_entry_internal(desc
, &err
))
133 strbuf_release(&err
);
136 int update_tree_entry_gently(struct tree_desc
*desc
)
138 struct strbuf err
= STRBUF_INIT
;
139 if (update_tree_entry_internal(desc
, &err
)) {
140 error("%s", err
.buf
);
141 strbuf_release(&err
);
142 /* Stop processing this tree after error */
146 strbuf_release(&err
);
150 int tree_entry(struct tree_desc
*desc
, struct name_entry
*entry
)
155 *entry
= desc
->entry
;
156 update_tree_entry(desc
);
160 int tree_entry_gently(struct tree_desc
*desc
, struct name_entry
*entry
)
165 *entry
= desc
->entry
;
166 if (update_tree_entry_gently(desc
))
171 void setup_traverse_info(struct traverse_info
*info
, const char *base
)
173 int pathlen
= strlen(base
);
174 static struct traverse_info dummy
;
176 memset(info
, 0, sizeof(*info
));
177 if (pathlen
&& base
[pathlen
-1] == '/')
179 info
->pathlen
= pathlen
? pathlen
+ 1 : 0;
180 info
->name
.path
= base
;
181 info
->name
.pathlen
= pathlen
;
183 hashcpy(info
->name
.oid
.hash
, (const unsigned char *)base
+ pathlen
+ 1);
188 char *make_traverse_path(char *path
, const struct traverse_info
*info
, const struct name_entry
*n
)
190 int len
= tree_entry_len(n
);
191 int pathlen
= info
->pathlen
;
193 path
[pathlen
+ len
] = 0;
195 memcpy(path
+ pathlen
, n
->path
, len
);
198 path
[--pathlen
] = '/';
200 len
= tree_entry_len(n
);
207 struct tree_desc_skip
{
208 struct tree_desc_skip
*prev
;
214 struct tree_desc_skip
*skip
;
217 static int check_entry_match(const char *a
, int a_len
, const char *b
, int b_len
)
220 * The caller wants to pick *a* from a tree or nothing.
221 * We are looking at *b* in a tree.
223 * (0) If a and b are the same name, we are trivially happy.
225 * There are three possibilities where *a* could be hiding
228 * (1) *a* == "t", *b* == "ab" i.e. *b* sorts earlier than *a* no
230 * (2) *a* == "t", *b* == "t-2" and "t" is a subtree in the tree;
231 * (3) *a* == "t-2", *b* == "t" and "t-2" is a blob in the tree.
233 * Otherwise we know *a* won't appear in the tree without
237 int cmp
= name_compare(a
, a_len
, b
, b_len
);
239 /* Most common case first -- reading sync'd trees */
244 /* a comes after b; it does not matter if it is case (3)
245 if (b_len < a_len && !memcmp(a, b, b_len) && a[b_len] < '/')
248 return 1; /* keep looking */
251 /* b comes after a; are we looking at case (2)? */
252 if (a_len
< b_len
&& !memcmp(a
, b
, a_len
) && b
[a_len
] < '/')
253 return 1; /* keep looking */
255 return -1; /* a cannot appear in the tree */
259 * From the extended tree_desc, extract the first name entry, while
260 * paying attention to the candidate "first" name. Most importantly,
261 * when looking for an entry, if there are entries that sorts earlier
262 * in the tree object representation than that name, skip them and
263 * process the named entry first. We will remember that we haven't
264 * processed the first entry yet, and in the later call skip the
265 * entry we processed early when update_extended_entry() is called.
267 * E.g. if the underlying tree object has these entries:
274 * and the "first" asks for "t", remember that we still need to
275 * process "t-1" and "t-2" but extract "t". After processing the
276 * entry "t" from this call, the caller will let us know by calling
277 * update_extended_entry() that we can remember "t" has been processed
281 static void extended_entry_extract(struct tree_desc_x
*t
,
282 struct name_entry
*a
,
288 struct tree_desc probe
;
289 struct tree_desc_skip
*skip
;
292 * Extract the first entry from the tree_desc, but skip the
293 * ones that we already returned in earlier rounds.
298 break; /* not found */
300 entry_extract(&t
->d
, a
);
301 for (skip
= t
->skip
; skip
; skip
= skip
->prev
)
302 if (a
->path
== skip
->ptr
)
306 /* We have processed this entry already. */
307 update_tree_entry(&t
->d
);
310 if (!first
|| !a
->path
)
314 * The caller wants "first" from this tree, or nothing.
317 len
= tree_entry_len(a
);
318 switch (check_entry_match(first
, first_len
, path
, len
)) {
328 * We need to look-ahead -- we suspect that a subtree whose
329 * name is "first" may be hiding behind the current entry "path".
333 entry_extract(&probe
, a
);
335 len
= tree_entry_len(a
);
336 switch (check_entry_match(first
, first_len
, path
, len
)) {
342 update_tree_entry(&probe
);
350 static void update_extended_entry(struct tree_desc_x
*t
, struct name_entry
*a
)
352 if (t
->d
.entry
.path
== a
->path
) {
353 update_tree_entry(&t
->d
);
355 /* we have returned this entry early */
356 struct tree_desc_skip
*skip
= xmalloc(sizeof(*skip
));
358 skip
->prev
= t
->skip
;
363 static void free_extended_entry(struct tree_desc_x
*t
)
365 struct tree_desc_skip
*p
, *s
;
367 for (s
= t
->skip
; s
; s
= p
) {
373 static inline int prune_traversal(struct index_state
*istate
,
374 struct name_entry
*e
,
375 struct traverse_info
*info
,
377 int still_interesting
)
379 if (!info
->pathspec
|| still_interesting
== 2)
381 if (still_interesting
< 0)
382 return still_interesting
;
383 return tree_entry_interesting(istate
, e
, base
,
387 int traverse_trees(struct index_state
*istate
,
388 int n
, struct tree_desc
*t
,
389 struct traverse_info
*info
)
392 struct name_entry
*entry
= xmalloc(n
*sizeof(*entry
));
394 struct tree_desc_x
*tx
= xcalloc(n
, sizeof(*tx
));
395 struct strbuf base
= STRBUF_INIT
;
399 for (i
= 0; i
< n
; i
++)
403 strbuf_grow(&base
, info
->pathlen
);
404 make_traverse_path(base
.buf
, info
->prev
, &info
->name
);
405 base
.buf
[info
->pathlen
-1] = '/';
406 strbuf_setlen(&base
, info
->pathlen
);
407 traverse_path
= xstrndup(base
.buf
, info
->pathlen
);
409 traverse_path
= xstrndup(info
->name
.path
, info
->pathlen
);
411 info
->traverse_path
= traverse_path
;
414 unsigned long mask
, dirmask
;
415 const char *first
= NULL
;
417 struct name_entry
*e
= NULL
;
420 for (i
= 0; i
< n
; i
++) {
422 extended_entry_extract(tx
+ i
, e
, NULL
, 0);
426 * A tree may have "t-2" at the current location even
427 * though it may have "t" that is a subtree behind it,
428 * and another tree may return "t". We want to grab
429 * all "t" from all trees to match in such a case.
431 for (i
= 0; i
< n
; i
++) {
435 len
= tree_entry_len(e
);
441 if (name_compare(e
->path
, len
, first
, first_len
) < 0) {
448 for (i
= 0; i
< n
; i
++) {
450 extended_entry_extract(tx
+ i
, e
, first
, first_len
);
451 /* Cull the ones that are not the earliest */
454 len
= tree_entry_len(e
);
455 if (name_compare(e
->path
, len
, first
, first_len
))
460 /* Now we have in entry[i] the earliest name from the trees */
463 for (i
= 0; i
< n
; i
++) {
467 if (S_ISDIR(entry
[i
].mode
))
473 interesting
= prune_traversal(istate
, e
, info
, &base
, interesting
);
477 trees_used
= info
->fn(n
, mask
, dirmask
, entry
, info
);
478 if (trees_used
< 0) {
480 if (!info
->show_all_errors
)
485 for (i
= 0; i
< n
; i
++)
486 if (mask
& (1ul << i
))
487 update_extended_entry(tx
+ i
, entry
+ i
);
490 for (i
= 0; i
< n
; i
++)
491 free_extended_entry(tx
+ i
);
494 info
->traverse_path
= NULL
;
495 strbuf_release(&base
);
502 struct object_id oid
;
505 static int find_tree_entry(struct tree_desc
*t
, const char *name
, struct object_id
*result
, unsigned short *mode
)
507 int namelen
= strlen(name
);
510 struct object_id oid
;
513 oidcpy(&oid
, tree_entry_extract(t
, &entry
, mode
));
514 entrylen
= tree_entry_len(&t
->entry
);
515 update_tree_entry(t
);
516 if (entrylen
> namelen
)
518 cmp
= memcmp(name
, entry
, entrylen
);
523 if (entrylen
== namelen
) {
524 oidcpy(result
, &oid
);
527 if (name
[entrylen
] != '/')
531 if (++entrylen
== namelen
) {
532 oidcpy(result
, &oid
);
535 return get_tree_entry(&oid
, name
+ entrylen
, result
, mode
);
540 int get_tree_entry(const struct object_id
*tree_oid
, const char *name
, struct object_id
*oid
, unsigned short *mode
)
545 struct object_id root
;
547 tree
= read_object_with_reference(the_repository
, tree_oid
, tree_type
, &size
, &root
);
551 if (name
[0] == '\0') {
561 init_tree_desc(&t
, tree
, size
);
562 retval
= find_tree_entry(&t
, name
, oid
, mode
);
569 * This is Linux's built-in max for the number of symlinks to follow.
570 * That limit, of course, does not affect git, but it's a reasonable
573 #define GET_TREE_ENTRY_FOLLOW_SYMLINKS_MAX_LINKS 40
576 * Find a tree entry by following symlinks in tree_sha (which is
577 * assumed to be the root of the repository). In the event that a
578 * symlink points outside the repository (e.g. a link to /foo or a
579 * root-level link to ../foo), the portion of the link which is
580 * outside the repository will be returned in result_path, and *mode
581 * will be set to 0. It is assumed that result_path is uninitialized.
582 * If there are no symlinks, or the end result of the symlink chain
583 * points to an object inside the repository, result will be filled in
584 * with the sha1 of the found object, and *mode will hold the mode of
587 * See the code for enum get_oid_result for a description of
590 enum get_oid_result
get_tree_entry_follow_symlinks(struct object_id
*tree_oid
, const char *name
, struct object_id
*result
, struct strbuf
*result_path
, unsigned short *mode
)
592 int retval
= MISSING_OBJECT
;
593 struct dir_state
*parents
= NULL
;
594 size_t parents_alloc
= 0;
595 size_t i
, parents_nr
= 0;
596 struct object_id current_tree_oid
;
597 struct strbuf namebuf
= STRBUF_INIT
;
599 int follows_remaining
= GET_TREE_ENTRY_FOLLOW_SYMLINKS_MAX_LINKS
;
601 init_tree_desc(&t
, NULL
, 0UL);
602 strbuf_addstr(&namebuf
, name
);
603 oidcpy(¤t_tree_oid
, tree_oid
);
608 char *remainder
= NULL
;
612 struct object_id root
;
614 tree
= read_object_with_reference(the_repository
,
621 ALLOC_GROW(parents
, parents_nr
+ 1, parents_alloc
);
622 parents
[parents_nr
].tree
= tree
;
623 parents
[parents_nr
].size
= size
;
624 oidcpy(&parents
[parents_nr
].oid
, &root
);
627 if (namebuf
.buf
[0] == '\0') {
628 oidcpy(result
, &root
);
637 init_tree_desc(&t
, tree
, size
);
640 /* Handle symlinks to e.g. a//b by removing leading slashes */
641 while (namebuf
.buf
[0] == '/') {
642 strbuf_remove(&namebuf
, 0, 1);
645 /* Split namebuf into a first component and a remainder */
646 if ((first_slash
= strchr(namebuf
.buf
, '/'))) {
648 remainder
= first_slash
+ 1;
651 if (!strcmp(namebuf
.buf
, "..")) {
652 struct dir_state
*parent
;
654 * We could end up with .. in the namebuf if it
655 * appears in a symlink.
658 if (parents_nr
== 1) {
661 strbuf_add(result_path
, namebuf
.buf
,
667 parent
= &parents
[parents_nr
- 1];
670 parent
= &parents
[parents_nr
- 1];
671 init_tree_desc(&t
, parent
->tree
, parent
->size
);
672 strbuf_remove(&namebuf
, 0, remainder
? 3 : 2);
676 /* We could end up here via a symlink to dir/.. */
677 if (namebuf
.buf
[0] == '\0') {
678 oidcpy(result
, &parents
[parents_nr
- 1].oid
);
683 /* Look up the first (or only) path component in the tree. */
684 find_result
= find_tree_entry(&t
, namebuf
.buf
,
685 ¤t_tree_oid
, mode
);
690 if (S_ISDIR(*mode
)) {
692 oidcpy(result
, ¤t_tree_oid
);
696 /* Descend the tree */
698 strbuf_remove(&namebuf
, 0,
699 1 + first_slash
- namebuf
.buf
);
700 } else if (S_ISREG(*mode
)) {
702 oidcpy(result
, ¤t_tree_oid
);
708 } else if (S_ISLNK(*mode
)) {
709 /* Follow a symlink */
710 unsigned long link_len
;
712 char *contents
, *contents_start
;
713 struct dir_state
*parent
;
714 enum object_type type
;
716 if (follows_remaining
-- == 0) {
717 /* Too many symlinks followed */
718 retval
= SYMLINK_LOOP
;
723 * At this point, we have followed at a least
724 * one symlink, so on error we need to report this.
726 retval
= DANGLING_SYMLINK
;
728 contents
= read_object_file(¤t_tree_oid
, &type
,
734 if (contents
[0] == '/') {
735 strbuf_addstr(result_path
, contents
);
743 len
= first_slash
- namebuf
.buf
;
747 contents_start
= contents
;
749 parent
= &parents
[parents_nr
- 1];
750 init_tree_desc(&t
, parent
->tree
, parent
->size
);
751 strbuf_splice(&namebuf
, 0, len
,
752 contents_start
, link_len
);
754 namebuf
.buf
[link_len
] = '/';
759 for (i
= 0; i
< parents_nr
; i
++)
760 free(parents
[i
].tree
);
763 strbuf_release(&namebuf
);
767 static int match_entry(const struct pathspec_item
*item
,
768 const struct name_entry
*entry
, int pathlen
,
769 const char *match
, int matchlen
,
770 enum interesting
*never_interesting
)
772 int m
= -1; /* signals that we haven't called strncmp() */
774 if (item
->magic
& PATHSPEC_ICASE
)
776 * "Never interesting" trick requires exact
777 * matching. We could do something clever with inexact
778 * matching, but it's trickier (and not to forget that
779 * strcasecmp is locale-dependent, at least in
780 * glibc). Just disable it for now. It can't be worse
781 * than the wildcard's codepath of '[Tt][Hi][Is][Ss]'
784 *never_interesting
= entry_not_interesting
;
785 else if (*never_interesting
!= entry_not_interesting
) {
787 * We have not seen any match that sorts later
788 * than the current path.
792 * Does match sort strictly earlier than path
793 * with their common parts?
795 m
= strncmp(match
, entry
->path
,
796 (matchlen
< pathlen
) ? matchlen
: pathlen
);
801 * If we come here even once, that means there is at
802 * least one pathspec that would sort equal to or
803 * later than the path we are currently looking at.
804 * In other words, if we have never reached this point
805 * after iterating all pathspecs, it means all
806 * pathspecs are either outside of base, or inside the
807 * base but sorts strictly earlier than the current
808 * one. In either case, they will never match the
809 * subsequent entries. In such a case, we initialized
810 * the variable to -1 and that is what will be
811 * returned, allowing the caller to terminate early.
813 *never_interesting
= entry_not_interesting
;
816 if (pathlen
> matchlen
)
819 if (matchlen
> pathlen
) {
820 if (match
[pathlen
] != '/')
822 if (!S_ISDIR(entry
->mode
) && !S_ISGITLINK(entry
->mode
))
828 * we cheated and did not do strncmp(), so we do
831 m
= ps_strncmp(item
, match
, entry
->path
, pathlen
);
834 * If common part matched earlier then it is a hit,
835 * because we rejected the case where path is not a
836 * leading directory and is shorter than match.
840 * match_entry does not check if the prefix part is
841 * matched case-sensitively. If the entry is a
842 * directory and part of prefix, it'll be rematched
843 * eventually by basecmp with special treatment for
851 /* :(icase)-aware string compare */
852 static int basecmp(const struct pathspec_item
*item
,
853 const char *base
, const char *match
, int len
)
855 if (item
->magic
& PATHSPEC_ICASE
) {
856 int ret
, n
= len
> item
->prefix
? item
->prefix
: len
;
857 ret
= strncmp(base
, match
, n
);
864 return ps_strncmp(item
, base
, match
, len
);
867 static int match_dir_prefix(const struct pathspec_item
*item
,
869 const char *match
, int matchlen
)
871 if (basecmp(item
, base
, match
, matchlen
))
875 * If the base is a subdirectory of a path which
876 * was specified, all of them are interesting.
879 base
[matchlen
] == '/' ||
880 match
[matchlen
- 1] == '/')
883 /* Just a random prefix match */
888 * Perform matching on the leading non-wildcard part of
889 * pathspec. item->nowildcard_len must be greater than zero. Return
890 * non-zero if base is matched.
892 static int match_wildcard_base(const struct pathspec_item
*item
,
893 const char *base
, int baselen
,
896 const char *match
= item
->match
;
897 /* the wildcard part is not considered in this function */
898 int matchlen
= item
->nowildcard_len
;
903 * Return early if base is longer than the
904 * non-wildcard part but it does not match.
906 if (baselen
>= matchlen
) {
908 return !basecmp(item
, base
, match
, matchlen
);
912 while (dirlen
&& match
[dirlen
- 1] != '/')
916 * Return early if base is shorter than the
917 * non-wildcard part but it does not match. Note that
918 * base ends with '/' so we are sure it really matches
921 if (basecmp(item
, base
, match
, baselen
))
927 * we could have checked entry against the non-wildcard part
928 * that is not in base and does similar never_interesting
929 * optimization as in match_entry. For now just be happy with
932 return entry_interesting
;
936 * Is a tree entry interesting given the pathspec we have?
938 * Pre-condition: either baselen == base_offset (i.e. empty path)
939 * or base[baselen-1] == '/' (i.e. with trailing slash).
941 static enum interesting
do_match(struct index_state
*istate
,
942 const struct name_entry
*entry
,
943 struct strbuf
*base
, int base_offset
,
944 const struct pathspec
*ps
,
948 int pathlen
, baselen
= base
->len
- base_offset
;
949 enum interesting never_interesting
= ps
->has_wildcard
?
950 entry_not_interesting
: all_entries_not_interesting
;
962 if (!ps
->recursive
||
963 !(ps
->magic
& PATHSPEC_MAXDEPTH
) ||
965 return all_entries_interesting
;
966 return within_depth(base
->buf
+ base_offset
, baselen
,
967 !!S_ISDIR(entry
->mode
),
969 entry_interesting
: entry_not_interesting
;
972 pathlen
= tree_entry_len(entry
);
974 for (i
= ps
->nr
- 1; i
>= 0; i
--) {
975 const struct pathspec_item
*item
= ps
->items
+i
;
976 const char *match
= item
->match
;
977 const char *base_str
= base
->buf
+ base_offset
;
978 int matchlen
= item
->len
, matched
= 0;
980 if ((!exclude
&& item
->magic
& PATHSPEC_EXCLUDE
) ||
981 ( exclude
&& !(item
->magic
& PATHSPEC_EXCLUDE
)))
984 if (baselen
>= matchlen
) {
985 /* If it doesn't match, move along... */
986 if (!match_dir_prefix(item
, base_str
, match
, matchlen
))
987 goto match_wildcards
;
989 if (!ps
->recursive
||
990 !(ps
->magic
& PATHSPEC_MAXDEPTH
) ||
991 ps
->max_depth
== -1) {
992 if (!item
->attr_match_nr
)
993 return all_entries_interesting
;
998 if (within_depth(base_str
+ matchlen
+ 1,
999 baselen
- matchlen
- 1,
1000 !!S_ISDIR(entry
->mode
),
1004 return entry_not_interesting
;
1007 /* Either there must be no base, or the base must match. */
1008 if (baselen
== 0 || !basecmp(item
, base_str
, match
, baselen
)) {
1009 if (match_entry(item
, entry
, pathlen
,
1010 match
+ baselen
, matchlen
- baselen
,
1011 &never_interesting
))
1014 if (item
->nowildcard_len
< item
->len
) {
1015 if (!git_fnmatch(item
, match
+ baselen
, entry
->path
,
1016 item
->nowildcard_len
- baselen
))
1020 * Match all directories. We'll try to
1021 * match files later on.
1023 if (ps
->recursive
&& S_ISDIR(entry
->mode
))
1024 return entry_interesting
;
1027 * When matching against submodules with
1028 * wildcard characters, ensure that the entry
1029 * at least matches up to the first wild
1030 * character. More accurate matching can then
1031 * be performed in the submodule itself.
1033 if (ps
->recurse_submodules
&&
1034 S_ISGITLINK(entry
->mode
) &&
1035 !ps_strncmp(item
, match
+ baselen
,
1037 item
->nowildcard_len
- baselen
))
1045 if (item
->nowildcard_len
== item
->len
)
1048 if (item
->nowildcard_len
&&
1049 !match_wildcard_base(item
, base_str
, baselen
, &matched
))
1053 * Concatenate base and entry->path into one and do
1056 * While we could avoid concatenation in certain cases
1057 * [1], which saves a memcpy and potentially a
1058 * realloc, it turns out not worth it. Measurement on
1059 * linux-2.6 does not show any clear improvements,
1060 * partly because of the nowildcard_len optimization
1061 * in git_fnmatch(). Avoid micro-optimizations here.
1063 * [1] if match_wildcard_base() says the base
1064 * directory is already matched, we only need to match
1065 * the rest, which is shorter so _in theory_ faster.
1068 strbuf_add(base
, entry
->path
, pathlen
);
1070 if (!git_fnmatch(item
, match
, base
->buf
+ base_offset
,
1071 item
->nowildcard_len
)) {
1072 strbuf_setlen(base
, base_offset
+ baselen
);
1077 * When matching against submodules with
1078 * wildcard characters, ensure that the entry
1079 * at least matches up to the first wild
1080 * character. More accurate matching can then
1081 * be performed in the submodule itself.
1083 if (ps
->recurse_submodules
&& S_ISGITLINK(entry
->mode
) &&
1084 !ps_strncmp(item
, match
, base
->buf
+ base_offset
,
1085 item
->nowildcard_len
)) {
1086 strbuf_setlen(base
, base_offset
+ baselen
);
1090 strbuf_setlen(base
, base_offset
+ baselen
);
1093 * Match all directories. We'll try to match files
1095 * max_depth is ignored but we may consider support it
1097 * https://public-inbox.org/git/7vmxo5l2g4.fsf@alter.siamese.dyndns.org/
1099 if (ps
->recursive
&& S_ISDIR(entry
->mode
))
1100 return entry_interesting
;
1103 if (item
->attr_match_nr
) {
1107 * Must not return all_entries_not_interesting
1108 * prematurely. We do not know if all entries do not
1109 * match some attributes with current attr API.
1111 never_interesting
= entry_not_interesting
;
1114 * Consider all directories interesting (because some
1115 * of those files inside may match some attributes
1116 * even though the parent dir does not)
1118 * FIXME: attributes _can_ match directories and we
1119 * can probably return all_entries_interesting or
1120 * all_entries_not_interesting here if matched.
1122 if (S_ISDIR(entry
->mode
))
1123 return entry_interesting
;
1125 strbuf_add(base
, entry
->path
, pathlen
);
1126 ret
= match_pathspec_attrs(istate
, base
->buf
+ base_offset
,
1127 base
->len
- base_offset
, item
);
1128 strbuf_setlen(base
, base_offset
+ baselen
);
1132 return entry_interesting
;
1134 return never_interesting
; /* No matches */
1138 * Is a tree entry interesting given the pathspec we have?
1140 * Pre-condition: either baselen == base_offset (i.e. empty path)
1141 * or base[baselen-1] == '/' (i.e. with trailing slash).
1143 enum interesting
tree_entry_interesting(struct index_state
*istate
,
1144 const struct name_entry
*entry
,
1145 struct strbuf
*base
, int base_offset
,
1146 const struct pathspec
*ps
)
1148 enum interesting positive
, negative
;
1149 positive
= do_match(istate
, entry
, base
, base_offset
, ps
, 0);
1152 * case | entry | positive | negative | result
1153 * -----+-------+----------+----------+-------
1154 * 1 | file | -1 | -1..2 | -1
1155 * 2 | file | 0 | -1..2 | 0
1156 * 3 | file | 1 | -1 | 1
1157 * 4 | file | 1 | 0 | 1
1158 * 5 | file | 1 | 1 | 0
1159 * 6 | file | 1 | 2 | 0
1160 * 7 | file | 2 | -1 | 2
1161 * 8 | file | 2 | 0 | 1
1162 * 9 | file | 2 | 1 | 0
1163 * 10 | file | 2 | 2 | -1
1164 * -----+-------+----------+----------+-------
1165 * 11 | dir | -1 | -1..2 | -1
1166 * 12 | dir | 0 | -1..2 | 0
1167 * 13 | dir | 1 | -1 | 1
1168 * 14 | dir | 1 | 0 | 1
1169 * 15 | dir | 1 | 1 | 1 (*)
1170 * 16 | dir | 1 | 2 | 0
1171 * 17 | dir | 2 | -1 | 2
1172 * 18 | dir | 2 | 0 | 1
1173 * 19 | dir | 2 | 1 | 1 (*)
1174 * 20 | dir | 2 | 2 | -1
1176 * (*) An exclude pattern interested in a directory does not
1177 * necessarily mean it will exclude all of the directory. In
1178 * wildcard case, it can't decide until looking at individual
1179 * files inside. So don't write such directories off yet.
1182 if (!(ps
->magic
& PATHSPEC_EXCLUDE
) ||
1183 positive
<= entry_not_interesting
) /* #1, #2, #11, #12 */
1186 negative
= do_match(istate
, entry
, base
, base_offset
, ps
, 1);
1189 if (positive
== all_entries_interesting
&&
1190 negative
== entry_not_interesting
)
1191 return entry_interesting
;
1193 /* #3, #4, #7, #13, #14, #17 */
1194 if (negative
<= entry_not_interesting
)
1198 if (S_ISDIR(entry
->mode
) &&
1199 positive
>= entry_interesting
&&
1200 negative
== entry_interesting
)
1201 return entry_interesting
;
1203 if ((positive
== entry_interesting
&&
1204 negative
>= entry_interesting
) || /* #5, #6, #16 */
1205 (positive
== all_entries_interesting
&&
1206 negative
== entry_interesting
)) /* #9 */
1207 return entry_not_interesting
;
1209 return all_entries_not_interesting
; /* #10, #20 */