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 size_t 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;
181 info
->namelen
= pathlen
;
186 char *make_traverse_path(char *path
, size_t pathlen
,
187 const struct traverse_info
*info
,
188 const char *name
, size_t namelen
)
190 /* Always points to the end of the name we're about to add */
191 size_t pos
= st_add(info
->pathlen
, namelen
);
194 BUG("too small buffer passed to make_traverse_path");
199 BUG("traverse_info pathlen does not match strings");
201 memcpy(path
+ pos
, name
, namelen
);
208 BUG("traverse_info ran out of list items");
210 namelen
= info
->namelen
;
216 void strbuf_make_traverse_path(struct strbuf
*out
,
217 const struct traverse_info
*info
,
218 const char *name
, size_t namelen
)
220 size_t len
= traverse_path_len(info
, namelen
);
222 strbuf_grow(out
, len
);
223 make_traverse_path(out
->buf
+ out
->len
, out
->alloc
- out
->len
,
224 info
, name
, namelen
);
225 strbuf_setlen(out
, out
->len
+ len
);
228 struct tree_desc_skip
{
229 struct tree_desc_skip
*prev
;
235 struct tree_desc_skip
*skip
;
238 static int check_entry_match(const char *a
, int a_len
, const char *b
, int b_len
)
241 * The caller wants to pick *a* from a tree or nothing.
242 * We are looking at *b* in a tree.
244 * (0) If a and b are the same name, we are trivially happy.
246 * There are three possibilities where *a* could be hiding
249 * (1) *a* == "t", *b* == "ab" i.e. *b* sorts earlier than *a* no
251 * (2) *a* == "t", *b* == "t-2" and "t" is a subtree in the tree;
252 * (3) *a* == "t-2", *b* == "t" and "t-2" is a blob in the tree.
254 * Otherwise we know *a* won't appear in the tree without
258 int cmp
= name_compare(a
, a_len
, b
, b_len
);
260 /* Most common case first -- reading sync'd trees */
265 /* a comes after b; it does not matter if it is case (3)
266 if (b_len < a_len && !memcmp(a, b, b_len) && a[b_len] < '/')
269 return 1; /* keep looking */
272 /* b comes after a; are we looking at case (2)? */
273 if (a_len
< b_len
&& !memcmp(a
, b
, a_len
) && b
[a_len
] < '/')
274 return 1; /* keep looking */
276 return -1; /* a cannot appear in the tree */
280 * From the extended tree_desc, extract the first name entry, while
281 * paying attention to the candidate "first" name. Most importantly,
282 * when looking for an entry, if there are entries that sorts earlier
283 * in the tree object representation than that name, skip them and
284 * process the named entry first. We will remember that we haven't
285 * processed the first entry yet, and in the later call skip the
286 * entry we processed early when update_extended_entry() is called.
288 * E.g. if the underlying tree object has these entries:
295 * and the "first" asks for "t", remember that we still need to
296 * process "t-1" and "t-2" but extract "t". After processing the
297 * entry "t" from this call, the caller will let us know by calling
298 * update_extended_entry() that we can remember "t" has been processed
302 static void extended_entry_extract(struct tree_desc_x
*t
,
303 struct name_entry
*a
,
309 struct tree_desc probe
;
310 struct tree_desc_skip
*skip
;
313 * Extract the first entry from the tree_desc, but skip the
314 * ones that we already returned in earlier rounds.
319 break; /* not found */
321 entry_extract(&t
->d
, a
);
322 for (skip
= t
->skip
; skip
; skip
= skip
->prev
)
323 if (a
->path
== skip
->ptr
)
327 /* We have processed this entry already. */
328 update_tree_entry(&t
->d
);
331 if (!first
|| !a
->path
)
335 * The caller wants "first" from this tree, or nothing.
338 len
= tree_entry_len(a
);
339 switch (check_entry_match(first
, first_len
, path
, len
)) {
349 * We need to look-ahead -- we suspect that a subtree whose
350 * name is "first" may be hiding behind the current entry "path".
354 entry_extract(&probe
, a
);
356 len
= tree_entry_len(a
);
357 switch (check_entry_match(first
, first_len
, path
, len
)) {
363 update_tree_entry(&probe
);
371 static void update_extended_entry(struct tree_desc_x
*t
, struct name_entry
*a
)
373 if (t
->d
.entry
.path
== a
->path
) {
374 update_tree_entry(&t
->d
);
376 /* we have returned this entry early */
377 struct tree_desc_skip
*skip
= xmalloc(sizeof(*skip
));
379 skip
->prev
= t
->skip
;
384 static void free_extended_entry(struct tree_desc_x
*t
)
386 struct tree_desc_skip
*p
, *s
;
388 for (s
= t
->skip
; s
; s
= p
) {
394 static inline int prune_traversal(struct index_state
*istate
,
395 struct name_entry
*e
,
396 struct traverse_info
*info
,
398 int still_interesting
)
400 if (!info
->pathspec
|| still_interesting
== 2)
402 if (still_interesting
< 0)
403 return still_interesting
;
404 return tree_entry_interesting(istate
, e
, base
,
408 int traverse_trees(struct index_state
*istate
,
409 int n
, struct tree_desc
*t
,
410 struct traverse_info
*info
)
413 struct name_entry
*entry
= xmalloc(n
*sizeof(*entry
));
415 struct tree_desc_x
*tx
= xcalloc(n
, sizeof(*tx
));
416 struct strbuf base
= STRBUF_INIT
;
420 for (i
= 0; i
< n
; i
++)
424 strbuf_make_traverse_path(&base
, info
->prev
,
425 info
->name
, info
->namelen
);
426 strbuf_addch(&base
, '/');
427 traverse_path
= xstrndup(base
.buf
, base
.len
);
429 traverse_path
= xstrndup(info
->name
, info
->pathlen
);
431 info
->traverse_path
= traverse_path
;
434 unsigned long mask
, dirmask
;
435 const char *first
= NULL
;
437 struct name_entry
*e
= NULL
;
440 for (i
= 0; i
< n
; i
++) {
442 extended_entry_extract(tx
+ i
, e
, NULL
, 0);
446 * A tree may have "t-2" at the current location even
447 * though it may have "t" that is a subtree behind it,
448 * and another tree may return "t". We want to grab
449 * all "t" from all trees to match in such a case.
451 for (i
= 0; i
< n
; i
++) {
455 len
= tree_entry_len(e
);
461 if (name_compare(e
->path
, len
, first
, first_len
) < 0) {
468 for (i
= 0; i
< n
; i
++) {
470 extended_entry_extract(tx
+ i
, e
, first
, first_len
);
471 /* Cull the ones that are not the earliest */
474 len
= tree_entry_len(e
);
475 if (name_compare(e
->path
, len
, first
, first_len
))
480 /* Now we have in entry[i] the earliest name from the trees */
483 for (i
= 0; i
< n
; i
++) {
487 if (S_ISDIR(entry
[i
].mode
))
493 interesting
= prune_traversal(istate
, e
, info
, &base
, interesting
);
497 trees_used
= info
->fn(n
, mask
, dirmask
, entry
, info
);
498 if (trees_used
< 0) {
500 if (!info
->show_all_errors
)
505 for (i
= 0; i
< n
; i
++)
506 if (mask
& (1ul << i
))
507 update_extended_entry(tx
+ i
, entry
+ i
);
510 for (i
= 0; i
< n
; i
++)
511 free_extended_entry(tx
+ i
);
514 info
->traverse_path
= NULL
;
515 strbuf_release(&base
);
522 struct object_id oid
;
525 static int find_tree_entry(struct repository
*r
, struct tree_desc
*t
,
526 const char *name
, struct object_id
*result
,
527 unsigned short *mode
)
529 int namelen
= strlen(name
);
532 struct object_id oid
;
535 oidcpy(&oid
, tree_entry_extract(t
, &entry
, mode
));
536 entrylen
= tree_entry_len(&t
->entry
);
537 update_tree_entry(t
);
538 if (entrylen
> namelen
)
540 cmp
= memcmp(name
, entry
, entrylen
);
545 if (entrylen
== namelen
) {
546 oidcpy(result
, &oid
);
549 if (name
[entrylen
] != '/')
553 if (++entrylen
== namelen
) {
554 oidcpy(result
, &oid
);
557 return get_tree_entry(r
, &oid
, name
+ entrylen
, result
, mode
);
562 int get_tree_entry(struct repository
*r
,
563 const struct object_id
*tree_oid
,
565 struct object_id
*oid
,
566 unsigned short *mode
)
571 struct object_id root
;
573 tree
= read_object_with_reference(r
, tree_oid
, tree_type
, &size
, &root
);
577 if (name
[0] == '\0') {
587 init_tree_desc(&t
, tree
, size
);
588 retval
= find_tree_entry(r
, &t
, name
, oid
, mode
);
595 * This is Linux's built-in max for the number of symlinks to follow.
596 * That limit, of course, does not affect git, but it's a reasonable
599 #define GET_TREE_ENTRY_FOLLOW_SYMLINKS_MAX_LINKS 40
602 * Find a tree entry by following symlinks in tree_sha (which is
603 * assumed to be the root of the repository). In the event that a
604 * symlink points outside the repository (e.g. a link to /foo or a
605 * root-level link to ../foo), the portion of the link which is
606 * outside the repository will be returned in result_path, and *mode
607 * will be set to 0. It is assumed that result_path is uninitialized.
608 * If there are no symlinks, or the end result of the symlink chain
609 * points to an object inside the repository, result will be filled in
610 * with the sha1 of the found object, and *mode will hold the mode of
613 * See the code for enum get_oid_result for a description of
616 enum get_oid_result
get_tree_entry_follow_symlinks(struct repository
*r
,
617 struct object_id
*tree_oid
, const char *name
,
618 struct object_id
*result
, struct strbuf
*result_path
,
619 unsigned short *mode
)
621 int retval
= MISSING_OBJECT
;
622 struct dir_state
*parents
= NULL
;
623 size_t parents_alloc
= 0;
624 size_t i
, parents_nr
= 0;
625 struct object_id current_tree_oid
;
626 struct strbuf namebuf
= STRBUF_INIT
;
628 int follows_remaining
= GET_TREE_ENTRY_FOLLOW_SYMLINKS_MAX_LINKS
;
630 init_tree_desc(&t
, NULL
, 0UL);
631 strbuf_addstr(&namebuf
, name
);
632 oidcpy(¤t_tree_oid
, tree_oid
);
637 char *remainder
= NULL
;
641 struct object_id root
;
643 tree
= read_object_with_reference(r
,
650 ALLOC_GROW(parents
, parents_nr
+ 1, parents_alloc
);
651 parents
[parents_nr
].tree
= tree
;
652 parents
[parents_nr
].size
= size
;
653 oidcpy(&parents
[parents_nr
].oid
, &root
);
656 if (namebuf
.buf
[0] == '\0') {
657 oidcpy(result
, &root
);
666 init_tree_desc(&t
, tree
, size
);
669 /* Handle symlinks to e.g. a//b by removing leading slashes */
670 while (namebuf
.buf
[0] == '/') {
671 strbuf_remove(&namebuf
, 0, 1);
674 /* Split namebuf into a first component and a remainder */
675 if ((first_slash
= strchr(namebuf
.buf
, '/'))) {
677 remainder
= first_slash
+ 1;
680 if (!strcmp(namebuf
.buf
, "..")) {
681 struct dir_state
*parent
;
683 * We could end up with .. in the namebuf if it
684 * appears in a symlink.
687 if (parents_nr
== 1) {
690 strbuf_add(result_path
, namebuf
.buf
,
696 parent
= &parents
[parents_nr
- 1];
699 parent
= &parents
[parents_nr
- 1];
700 init_tree_desc(&t
, parent
->tree
, parent
->size
);
701 strbuf_remove(&namebuf
, 0, remainder
? 3 : 2);
705 /* We could end up here via a symlink to dir/.. */
706 if (namebuf
.buf
[0] == '\0') {
707 oidcpy(result
, &parents
[parents_nr
- 1].oid
);
712 /* Look up the first (or only) path component in the tree. */
713 find_result
= find_tree_entry(r
, &t
, namebuf
.buf
,
714 ¤t_tree_oid
, mode
);
719 if (S_ISDIR(*mode
)) {
721 oidcpy(result
, ¤t_tree_oid
);
725 /* Descend the tree */
727 strbuf_remove(&namebuf
, 0,
728 1 + first_slash
- namebuf
.buf
);
729 } else if (S_ISREG(*mode
)) {
731 oidcpy(result
, ¤t_tree_oid
);
737 } else if (S_ISLNK(*mode
)) {
738 /* Follow a symlink */
739 unsigned long link_len
;
741 char *contents
, *contents_start
;
742 struct dir_state
*parent
;
743 enum object_type type
;
745 if (follows_remaining
-- == 0) {
746 /* Too many symlinks followed */
747 retval
= SYMLINK_LOOP
;
752 * At this point, we have followed at a least
753 * one symlink, so on error we need to report this.
755 retval
= DANGLING_SYMLINK
;
757 contents
= repo_read_object_file(r
,
758 ¤t_tree_oid
, &type
,
764 if (contents
[0] == '/') {
765 strbuf_addstr(result_path
, contents
);
773 len
= first_slash
- namebuf
.buf
;
777 contents_start
= contents
;
779 parent
= &parents
[parents_nr
- 1];
780 init_tree_desc(&t
, parent
->tree
, parent
->size
);
781 strbuf_splice(&namebuf
, 0, len
,
782 contents_start
, link_len
);
784 namebuf
.buf
[link_len
] = '/';
789 for (i
= 0; i
< parents_nr
; i
++)
790 free(parents
[i
].tree
);
793 strbuf_release(&namebuf
);
797 static int match_entry(const struct pathspec_item
*item
,
798 const struct name_entry
*entry
, int pathlen
,
799 const char *match
, int matchlen
,
800 enum interesting
*never_interesting
)
802 int m
= -1; /* signals that we haven't called strncmp() */
804 if (item
->magic
& PATHSPEC_ICASE
)
806 * "Never interesting" trick requires exact
807 * matching. We could do something clever with inexact
808 * matching, but it's trickier (and not to forget that
809 * strcasecmp is locale-dependent, at least in
810 * glibc). Just disable it for now. It can't be worse
811 * than the wildcard's codepath of '[Tt][Hi][Is][Ss]'
814 *never_interesting
= entry_not_interesting
;
815 else if (*never_interesting
!= entry_not_interesting
) {
817 * We have not seen any match that sorts later
818 * than the current path.
822 * Does match sort strictly earlier than path
823 * with their common parts?
825 m
= strncmp(match
, entry
->path
,
826 (matchlen
< pathlen
) ? matchlen
: pathlen
);
831 * If we come here even once, that means there is at
832 * least one pathspec that would sort equal to or
833 * later than the path we are currently looking at.
834 * In other words, if we have never reached this point
835 * after iterating all pathspecs, it means all
836 * pathspecs are either outside of base, or inside the
837 * base but sorts strictly earlier than the current
838 * one. In either case, they will never match the
839 * subsequent entries. In such a case, we initialized
840 * the variable to -1 and that is what will be
841 * returned, allowing the caller to terminate early.
843 *never_interesting
= entry_not_interesting
;
846 if (pathlen
> matchlen
)
849 if (matchlen
> pathlen
) {
850 if (match
[pathlen
] != '/')
852 if (!S_ISDIR(entry
->mode
) && !S_ISGITLINK(entry
->mode
))
858 * we cheated and did not do strncmp(), so we do
861 m
= ps_strncmp(item
, match
, entry
->path
, pathlen
);
864 * If common part matched earlier then it is a hit,
865 * because we rejected the case where path is not a
866 * leading directory and is shorter than match.
870 * match_entry does not check if the prefix part is
871 * matched case-sensitively. If the entry is a
872 * directory and part of prefix, it'll be rematched
873 * eventually by basecmp with special treatment for
881 /* :(icase)-aware string compare */
882 static int basecmp(const struct pathspec_item
*item
,
883 const char *base
, const char *match
, int len
)
885 if (item
->magic
& PATHSPEC_ICASE
) {
886 int ret
, n
= len
> item
->prefix
? item
->prefix
: len
;
887 ret
= strncmp(base
, match
, n
);
894 return ps_strncmp(item
, base
, match
, len
);
897 static int match_dir_prefix(const struct pathspec_item
*item
,
899 const char *match
, int matchlen
)
901 if (basecmp(item
, base
, match
, matchlen
))
905 * If the base is a subdirectory of a path which
906 * was specified, all of them are interesting.
909 base
[matchlen
] == '/' ||
910 match
[matchlen
- 1] == '/')
913 /* Just a random prefix match */
918 * Perform matching on the leading non-wildcard part of
919 * pathspec. item->nowildcard_len must be greater than zero. Return
920 * non-zero if base is matched.
922 static int match_wildcard_base(const struct pathspec_item
*item
,
923 const char *base
, int baselen
,
926 const char *match
= item
->match
;
927 /* the wildcard part is not considered in this function */
928 int matchlen
= item
->nowildcard_len
;
933 * Return early if base is longer than the
934 * non-wildcard part but it does not match.
936 if (baselen
>= matchlen
) {
938 return !basecmp(item
, base
, match
, matchlen
);
942 while (dirlen
&& match
[dirlen
- 1] != '/')
946 * Return early if base is shorter than the
947 * non-wildcard part but it does not match. Note that
948 * base ends with '/' so we are sure it really matches
951 if (basecmp(item
, base
, match
, baselen
))
957 * we could have checked entry against the non-wildcard part
958 * that is not in base and does similar never_interesting
959 * optimization as in match_entry. For now just be happy with
962 return entry_interesting
;
966 * Is a tree entry interesting given the pathspec we have?
968 * Pre-condition: either baselen == base_offset (i.e. empty path)
969 * or base[baselen-1] == '/' (i.e. with trailing slash).
971 static enum interesting
do_match(struct index_state
*istate
,
972 const struct name_entry
*entry
,
973 struct strbuf
*base
, int base_offset
,
974 const struct pathspec
*ps
,
978 int pathlen
, baselen
= base
->len
- base_offset
;
979 enum interesting never_interesting
= ps
->has_wildcard
?
980 entry_not_interesting
: all_entries_not_interesting
;
992 if (!ps
->recursive
||
993 !(ps
->magic
& PATHSPEC_MAXDEPTH
) ||
995 return all_entries_interesting
;
996 return within_depth(base
->buf
+ base_offset
, baselen
,
997 !!S_ISDIR(entry
->mode
),
999 entry_interesting
: entry_not_interesting
;
1002 pathlen
= tree_entry_len(entry
);
1004 for (i
= ps
->nr
- 1; i
>= 0; i
--) {
1005 const struct pathspec_item
*item
= ps
->items
+i
;
1006 const char *match
= item
->match
;
1007 const char *base_str
= base
->buf
+ base_offset
;
1008 int matchlen
= item
->len
, matched
= 0;
1010 if ((!exclude
&& item
->magic
& PATHSPEC_EXCLUDE
) ||
1011 ( exclude
&& !(item
->magic
& PATHSPEC_EXCLUDE
)))
1014 if (baselen
>= matchlen
) {
1015 /* If it doesn't match, move along... */
1016 if (!match_dir_prefix(item
, base_str
, match
, matchlen
))
1017 goto match_wildcards
;
1019 if (!ps
->recursive
||
1020 !(ps
->magic
& PATHSPEC_MAXDEPTH
) ||
1021 ps
->max_depth
== -1) {
1022 if (!item
->attr_match_nr
)
1023 return all_entries_interesting
;
1028 if (within_depth(base_str
+ matchlen
+ 1,
1029 baselen
- matchlen
- 1,
1030 !!S_ISDIR(entry
->mode
),
1034 return entry_not_interesting
;
1037 /* Either there must be no base, or the base must match. */
1038 if (baselen
== 0 || !basecmp(item
, base_str
, match
, baselen
)) {
1039 if (match_entry(item
, entry
, pathlen
,
1040 match
+ baselen
, matchlen
- baselen
,
1041 &never_interesting
))
1044 if (item
->nowildcard_len
< item
->len
) {
1045 if (!git_fnmatch(item
, match
+ baselen
, entry
->path
,
1046 item
->nowildcard_len
- baselen
))
1050 * Match all directories. We'll try to
1051 * match files later on.
1053 if (ps
->recursive
&& S_ISDIR(entry
->mode
))
1054 return entry_interesting
;
1057 * When matching against submodules with
1058 * wildcard characters, ensure that the entry
1059 * at least matches up to the first wild
1060 * character. More accurate matching can then
1061 * be performed in the submodule itself.
1063 if (ps
->recurse_submodules
&&
1064 S_ISGITLINK(entry
->mode
) &&
1065 !ps_strncmp(item
, match
+ baselen
,
1067 item
->nowildcard_len
- baselen
))
1075 if (item
->nowildcard_len
== item
->len
)
1078 if (item
->nowildcard_len
&&
1079 !match_wildcard_base(item
, base_str
, baselen
, &matched
))
1083 * Concatenate base and entry->path into one and do
1086 * While we could avoid concatenation in certain cases
1087 * [1], which saves a memcpy and potentially a
1088 * realloc, it turns out not worth it. Measurement on
1089 * linux-2.6 does not show any clear improvements,
1090 * partly because of the nowildcard_len optimization
1091 * in git_fnmatch(). Avoid micro-optimizations here.
1093 * [1] if match_wildcard_base() says the base
1094 * directory is already matched, we only need to match
1095 * the rest, which is shorter so _in theory_ faster.
1098 strbuf_add(base
, entry
->path
, pathlen
);
1100 if (!git_fnmatch(item
, match
, base
->buf
+ base_offset
,
1101 item
->nowildcard_len
)) {
1102 strbuf_setlen(base
, base_offset
+ baselen
);
1107 * When matching against submodules with
1108 * wildcard characters, ensure that the entry
1109 * at least matches up to the first wild
1110 * character. More accurate matching can then
1111 * be performed in the submodule itself.
1113 if (ps
->recurse_submodules
&& S_ISGITLINK(entry
->mode
) &&
1114 !ps_strncmp(item
, match
, base
->buf
+ base_offset
,
1115 item
->nowildcard_len
)) {
1116 strbuf_setlen(base
, base_offset
+ baselen
);
1120 strbuf_setlen(base
, base_offset
+ baselen
);
1123 * Match all directories. We'll try to match files
1125 * max_depth is ignored but we may consider support it
1127 * https://lore.kernel.org/git/7vmxo5l2g4.fsf@alter.siamese.dyndns.org/
1129 if (ps
->recursive
&& S_ISDIR(entry
->mode
))
1130 return entry_interesting
;
1133 if (item
->attr_match_nr
) {
1137 * Must not return all_entries_not_interesting
1138 * prematurely. We do not know if all entries do not
1139 * match some attributes with current attr API.
1141 never_interesting
= entry_not_interesting
;
1144 * Consider all directories interesting (because some
1145 * of those files inside may match some attributes
1146 * even though the parent dir does not)
1148 * FIXME: attributes _can_ match directories and we
1149 * can probably return all_entries_interesting or
1150 * all_entries_not_interesting here if matched.
1152 if (S_ISDIR(entry
->mode
))
1153 return entry_interesting
;
1155 strbuf_add(base
, entry
->path
, pathlen
);
1156 ret
= match_pathspec_attrs(istate
, base
->buf
+ base_offset
,
1157 base
->len
- base_offset
, item
);
1158 strbuf_setlen(base
, base_offset
+ baselen
);
1162 return entry_interesting
;
1164 return never_interesting
; /* No matches */
1168 * Is a tree entry interesting given the pathspec we have?
1170 * Pre-condition: either baselen == base_offset (i.e. empty path)
1171 * or base[baselen-1] == '/' (i.e. with trailing slash).
1173 enum interesting
tree_entry_interesting(struct index_state
*istate
,
1174 const struct name_entry
*entry
,
1175 struct strbuf
*base
, int base_offset
,
1176 const struct pathspec
*ps
)
1178 enum interesting positive
, negative
;
1179 positive
= do_match(istate
, entry
, base
, base_offset
, ps
, 0);
1182 * case | entry | positive | negative | result
1183 * -----+-------+----------+----------+-------
1184 * 1 | file | -1 | -1..2 | -1
1185 * 2 | file | 0 | -1..2 | 0
1186 * 3 | file | 1 | -1 | 1
1187 * 4 | file | 1 | 0 | 1
1188 * 5 | file | 1 | 1 | 0
1189 * 6 | file | 1 | 2 | 0
1190 * 7 | file | 2 | -1 | 2
1191 * 8 | file | 2 | 0 | 1
1192 * 9 | file | 2 | 1 | 0
1193 * 10 | file | 2 | 2 | -1
1194 * -----+-------+----------+----------+-------
1195 * 11 | dir | -1 | -1..2 | -1
1196 * 12 | dir | 0 | -1..2 | 0
1197 * 13 | dir | 1 | -1 | 1
1198 * 14 | dir | 1 | 0 | 1
1199 * 15 | dir | 1 | 1 | 1 (*)
1200 * 16 | dir | 1 | 2 | 0
1201 * 17 | dir | 2 | -1 | 2
1202 * 18 | dir | 2 | 0 | 1
1203 * 19 | dir | 2 | 1 | 1 (*)
1204 * 20 | dir | 2 | 2 | -1
1206 * (*) An exclude pattern interested in a directory does not
1207 * necessarily mean it will exclude all of the directory. In
1208 * wildcard case, it can't decide until looking at individual
1209 * files inside. So don't write such directories off yet.
1212 if (!(ps
->magic
& PATHSPEC_EXCLUDE
) ||
1213 positive
<= entry_not_interesting
) /* #1, #2, #11, #12 */
1216 negative
= do_match(istate
, entry
, base
, base_offset
, ps
, 1);
1219 if (positive
== all_entries_interesting
&&
1220 negative
== entry_not_interesting
)
1221 return entry_interesting
;
1223 /* #3, #4, #7, #13, #14, #17 */
1224 if (negative
<= entry_not_interesting
)
1228 if (S_ISDIR(entry
->mode
) &&
1229 positive
>= entry_interesting
&&
1230 negative
== entry_interesting
)
1231 return entry_interesting
;
1233 if ((positive
== entry_interesting
&&
1234 negative
>= entry_interesting
) || /* #5, #6, #16 */
1235 (positive
== all_entries_interesting
&&
1236 negative
== entry_interesting
)) /* #9 */
1237 return entry_not_interesting
;
1239 return all_entries_not_interesting
; /* #10, #20 */