2 * This handles recursive filename detection with exclude
3 * files, index knowledge etc..
5 * Copyright (C) Linus Torvalds, 2005-2006
6 * Junio Hamano, 2005-2006
8 #include "git-compat-util.h"
13 #include "environment.h"
15 #include "name-hash.h"
16 #include "object-file.h"
17 #include "object-store-ll.h"
20 #include "wildmatch.h"
24 #include "ewah/ewok.h"
25 #include "fsmonitor-ll.h"
26 #include "read-cache-ll.h"
28 #include "sparse-index.h"
29 #include "submodule-config.h"
35 * Tells read_directory_recursive how a file or directory should be treated.
36 * Values are ordered by significance, e.g. if a directory contains both
37 * excluded and untracked files, it is listed as untracked because
38 * path_untracked > path_excluded.
48 * Support data structure for our opendir/readdir/closedir wrappers
52 struct untracked_cache_dir
*untracked
;
59 struct untracked_cache_dir
*ucd
;
62 static enum path_treatment
read_directory_recursive(struct dir_struct
*dir
,
63 struct index_state
*istate
, const char *path
, int len
,
64 struct untracked_cache_dir
*untracked
,
65 int check_only
, int stop_at_first_file
, const struct pathspec
*pathspec
);
66 static int resolve_dtype(int dtype
, struct index_state
*istate
,
67 const char *path
, int len
);
68 struct dirent
*readdir_skip_dot_and_dotdot(DIR *dirp
)
72 while ((e
= readdir(dirp
)) != NULL
) {
73 if (!is_dot_or_dotdot(e
->d_name
))
79 int count_slashes(const char *s
)
88 int fspathcmp(const char *a
, const char *b
)
90 return ignore_case
? strcasecmp(a
, b
) : strcmp(a
, b
);
93 int fspatheq(const char *a
, const char *b
)
95 return !fspathcmp(a
, b
);
98 int fspathncmp(const char *a
, const char *b
, size_t count
)
100 return ignore_case
? strncasecmp(a
, b
, count
) : strncmp(a
, b
, count
);
103 int paths_collide(const char *a
, const char *b
)
105 size_t len_a
= strlen(a
), len_b
= strlen(b
);
108 return fspatheq(a
, b
);
111 return is_dir_sep(b
[len_a
]) && !fspathncmp(a
, b
, len_a
);
112 return is_dir_sep(a
[len_b
]) && !fspathncmp(a
, b
, len_b
);
115 unsigned int fspathhash(const char *str
)
117 return ignore_case
? strihash(str
) : strhash(str
);
120 int git_fnmatch(const struct pathspec_item
*item
,
121 const char *pattern
, const char *string
,
125 if (ps_strncmp(item
, pattern
, string
, prefix
))
130 if (item
->flags
& PATHSPEC_ONESTAR
) {
131 int pattern_len
= strlen(++pattern
);
132 int string_len
= strlen(string
);
133 return string_len
< pattern_len
||
134 ps_strcmp(item
, pattern
,
135 string
+ string_len
- pattern_len
);
137 if (item
->magic
& PATHSPEC_GLOB
)
138 return wildmatch(pattern
, string
,
140 (item
->magic
& PATHSPEC_ICASE
? WM_CASEFOLD
: 0));
142 /* wildmatch has not learned no FNM_PATHNAME mode yet */
143 return wildmatch(pattern
, string
,
144 item
->magic
& PATHSPEC_ICASE
? WM_CASEFOLD
: 0);
147 static int fnmatch_icase_mem(const char *pattern
, int patternlen
,
148 const char *string
, int stringlen
,
152 struct strbuf pat_buf
= STRBUF_INIT
;
153 struct strbuf str_buf
= STRBUF_INIT
;
154 const char *use_pat
= pattern
;
155 const char *use_str
= string
;
157 if (pattern
[patternlen
]) {
158 strbuf_add(&pat_buf
, pattern
, patternlen
);
159 use_pat
= pat_buf
.buf
;
161 if (string
[stringlen
]) {
162 strbuf_add(&str_buf
, string
, stringlen
);
163 use_str
= str_buf
.buf
;
167 flags
|= WM_CASEFOLD
;
168 match_status
= wildmatch(use_pat
, use_str
, flags
);
170 strbuf_release(&pat_buf
);
171 strbuf_release(&str_buf
);
176 static size_t common_prefix_len(const struct pathspec
*pathspec
)
182 * ":(icase)path" is treated as a pathspec full of
183 * wildcard. In other words, only prefix is considered common
184 * prefix. If the pathspec is abc/foo abc/bar, running in
185 * subdir xyz, the common prefix is still xyz, not xyz/abc as
188 GUARD_PATHSPEC(pathspec
,
197 for (n
= 0; n
< pathspec
->nr
; n
++) {
198 size_t i
= 0, len
= 0, item_len
;
199 if (pathspec
->items
[n
].magic
& PATHSPEC_EXCLUDE
)
201 if (pathspec
->items
[n
].magic
& PATHSPEC_ICASE
)
202 item_len
= pathspec
->items
[n
].prefix
;
204 item_len
= pathspec
->items
[n
].nowildcard_len
;
205 while (i
< item_len
&& (n
== 0 || i
< max
)) {
206 char c
= pathspec
->items
[n
].match
[i
];
207 if (c
!= pathspec
->items
[0].match
[i
])
213 if (n
== 0 || len
< max
) {
223 * Returns a copy of the longest leading path common among all
226 char *common_prefix(const struct pathspec
*pathspec
)
228 unsigned long len
= common_prefix_len(pathspec
);
230 return len
? xmemdupz(pathspec
->items
[0].match
, len
) : NULL
;
233 int fill_directory(struct dir_struct
*dir
,
234 struct index_state
*istate
,
235 const struct pathspec
*pathspec
)
240 unsigned exclusive_flags
= DIR_SHOW_IGNORED
| DIR_SHOW_IGNORED_TOO
;
241 if ((dir
->flags
& exclusive_flags
) == exclusive_flags
)
242 BUG("DIR_SHOW_IGNORED and DIR_SHOW_IGNORED_TOO are exclusive");
245 * Calculate common prefix for the pathspec, and
246 * use that to optimize the directory walk
248 prefix_len
= common_prefix_len(pathspec
);
249 prefix
= prefix_len
? pathspec
->items
[0].match
: "";
251 /* Read the directory and prune it */
252 read_directory(dir
, istate
, prefix
, prefix_len
, pathspec
);
257 int within_depth(const char *name
, int namelen
,
258 int depth
, int max_depth
)
260 const char *cp
= name
, *cpe
= name
+ namelen
;
266 if (depth
> max_depth
)
273 * Read the contents of the blob with the given OID into a buffer.
274 * Append a trailing LF to the end if the last line doesn't have one.
277 * -1 when the OID is invalid or unknown or does not refer to a blob.
278 * 0 when the blob is empty.
279 * 1 along with { data, size } of the (possibly augmented) buffer
282 * Optionally updates the given oid_stat with the given OID (when valid).
284 static int do_read_blob(const struct object_id
*oid
, struct oid_stat
*oid_stat
,
285 size_t *size_out
, char **data_out
)
287 enum object_type type
;
294 data
= repo_read_object_file(the_repository
, oid
, &type
, &sz
);
295 if (!data
|| type
!= OBJ_BLOB
) {
301 memset(&oid_stat
->stat
, 0, sizeof(oid_stat
->stat
));
302 oidcpy(&oid_stat
->oid
, oid
);
310 if (data
[sz
- 1] != '\n') {
311 data
= xrealloc(data
, st_add(sz
, 1));
315 *size_out
= xsize_t(sz
);
321 #define DO_MATCH_EXCLUDE (1<<0)
322 #define DO_MATCH_DIRECTORY (1<<1)
323 #define DO_MATCH_LEADING_PATHSPEC (1<<2)
326 * Does the given pathspec match the given name? A match is found if
328 * (1) the pathspec string is leading directory of 'name' ("RECURSIVELY"), or
329 * (2) the pathspec string has a leading part matching 'name' ("LEADING"), or
330 * (3) the pathspec string is a wildcard and matches 'name' ("WILDCARD"), or
331 * (4) the pathspec string is exactly the same as 'name' ("EXACT").
333 * Return value tells which case it was (1-4), or 0 when there is no match.
335 * It may be instructive to look at a small table of concrete examples
336 * to understand the differences between 1, 2, and 4:
339 * | a/b | a/b/ | a/b/c
340 * ------+-----------+-----------+------------
341 * a/b | EXACT | EXACT[1] | LEADING[2]
342 * Names a/b/ | RECURSIVE | EXACT | LEADING[2]
343 * a/b/c | RECURSIVE | RECURSIVE | EXACT
345 * [1] Only if DO_MATCH_DIRECTORY is passed; otherwise, this is NOT a match.
346 * [2] Only if DO_MATCH_LEADING_PATHSPEC is passed; otherwise, not a match.
348 static int match_pathspec_item(struct index_state
*istate
,
349 const struct pathspec_item
*item
, int prefix
,
350 const char *name
, int namelen
, unsigned flags
)
352 /* name/namelen has prefix cut off by caller */
353 const char *match
= item
->match
+ prefix
;
354 int matchlen
= item
->len
- prefix
;
357 * The normal call pattern is:
358 * 1. prefix = common_prefix_len(ps);
359 * 2. prune something, or fill_directory
360 * 3. match_pathspec()
362 * 'prefix' at #1 may be shorter than the command's prefix and
363 * it's ok for #2 to match extra files. Those extras will be
366 * Suppose the pathspec is 'foo' and '../bar' running from
367 * subdir 'xyz'. The common prefix at #1 will be empty, thanks
368 * to "../". We may have xyz/foo _and_ XYZ/foo after #2. The
369 * user does not want XYZ/foo, only the "foo" part should be
370 * case-insensitive. We need to filter out XYZ/foo here. In
371 * other words, we do not trust the caller on comparing the
372 * prefix part when :(icase) is involved. We do exact
373 * comparison ourselves.
375 * Normally the caller (common_prefix_len() in fact) does
376 * _exact_ matching on name[-prefix+1..-1] and we do not need
377 * to check that part. Be defensive and check it anyway, in
378 * case common_prefix_len is changed, or a new caller is
379 * introduced that does not use common_prefix_len.
381 * If the penalty turns out too high when prefix is really
382 * long, maybe change it to
383 * strncmp(match, name, item->prefix - prefix)
385 if (item
->prefix
&& (item
->magic
& PATHSPEC_ICASE
) &&
386 strncmp(item
->match
, name
- prefix
, item
->prefix
))
389 if (item
->attr_match_nr
&&
390 !match_pathspec_attrs(istate
, name
- prefix
, namelen
+ prefix
, item
))
393 /* If the match was just the prefix, we matched */
395 return MATCHED_RECURSIVELY
;
397 if (matchlen
<= namelen
&& !ps_strncmp(item
, match
, name
, matchlen
)) {
398 if (matchlen
== namelen
)
399 return MATCHED_EXACTLY
;
401 if (match
[matchlen
-1] == '/' || name
[matchlen
] == '/')
402 return MATCHED_RECURSIVELY
;
403 } else if ((flags
& DO_MATCH_DIRECTORY
) &&
404 match
[matchlen
- 1] == '/' &&
405 namelen
== matchlen
- 1 &&
406 !ps_strncmp(item
, match
, name
, namelen
))
407 return MATCHED_EXACTLY
;
409 if (item
->nowildcard_len
< item
->len
&&
410 !git_fnmatch(item
, match
, name
,
411 item
->nowildcard_len
- prefix
))
412 return MATCHED_FNMATCH
;
414 /* Perform checks to see if "name" is a leading string of the pathspec */
415 if ( (flags
& DO_MATCH_LEADING_PATHSPEC
) &&
416 !(flags
& DO_MATCH_EXCLUDE
)) {
417 /* name is a literal prefix of the pathspec */
418 int offset
= name
[namelen
-1] == '/' ? 1 : 0;
419 if ((namelen
< matchlen
) &&
420 (match
[namelen
-offset
] == '/') &&
421 !ps_strncmp(item
, match
, name
, namelen
))
422 return MATCHED_RECURSIVELY_LEADING_PATHSPEC
;
424 /* name doesn't match up to the first wild character */
425 if (item
->nowildcard_len
< item
->len
&&
426 ps_strncmp(item
, match
, name
,
427 item
->nowildcard_len
- prefix
))
431 * name has no wildcard, and it didn't match as a leading
432 * pathspec so return.
434 if (item
->nowildcard_len
== item
->len
)
438 * Here is where we would perform a wildmatch to check if
439 * "name" can be matched as a directory (or a prefix) against
440 * the pathspec. Since wildmatch doesn't have this capability
441 * at the present we have to punt and say that it is a match,
442 * potentially returning a false positive
443 * The submodules themselves will be able to perform more
444 * accurate matching to determine if the pathspec matches.
446 return MATCHED_RECURSIVELY_LEADING_PATHSPEC
;
453 * do_match_pathspec() is meant to ONLY be called by
454 * match_pathspec_with_flags(); calling it directly risks pathspecs
455 * like ':!unwanted_path' being ignored.
457 * Given a name and a list of pathspecs, returns the nature of the
458 * closest (i.e. most specific) match of the name to any of the
461 * The caller typically calls this multiple times with the same
462 * pathspec and seen[] array but with different name/namelen
463 * (e.g. entries from the index) and is interested in seeing if and
464 * how each pathspec matches all the names it calls this function
465 * with. A mark is left in the seen[] array for each pathspec element
466 * indicating the closest type of match that element achieved, so if
467 * seen[n] remains zero after multiple invocations, that means the nth
468 * pathspec did not match any names, which could indicate that the
469 * user mistyped the nth pathspec.
471 static int do_match_pathspec(struct index_state
*istate
,
472 const struct pathspec
*ps
,
473 const char *name
, int namelen
,
474 int prefix
, char *seen
,
477 int i
, retval
= 0, exclude
= flags
& DO_MATCH_EXCLUDE
;
489 if (!ps
->recursive
||
490 !(ps
->magic
& PATHSPEC_MAXDEPTH
) ||
492 return MATCHED_RECURSIVELY
;
494 if (within_depth(name
, namelen
, 0, ps
->max_depth
))
495 return MATCHED_EXACTLY
;
503 for (i
= ps
->nr
- 1; i
>= 0; i
--) {
506 if ((!exclude
&& ps
->items
[i
].magic
& PATHSPEC_EXCLUDE
) ||
507 ( exclude
&& !(ps
->items
[i
].magic
& PATHSPEC_EXCLUDE
)))
510 if (seen
&& seen
[i
] == MATCHED_EXACTLY
)
513 * Make exclude patterns optional and never report
514 * "pathspec ':(exclude)foo' matches no files"
516 if (seen
&& ps
->items
[i
].magic
& PATHSPEC_EXCLUDE
)
517 seen
[i
] = MATCHED_FNMATCH
;
518 how
= match_pathspec_item(istate
, ps
->items
+i
, prefix
, name
,
521 (ps
->magic
& PATHSPEC_MAXDEPTH
) &&
522 ps
->max_depth
!= -1 &&
523 how
&& how
!= MATCHED_FNMATCH
) {
524 int len
= ps
->items
[i
].len
;
525 if (name
[len
] == '/')
527 if (within_depth(name
+len
, namelen
-len
, 0, ps
->max_depth
))
528 how
= MATCHED_EXACTLY
;
535 if (seen
&& seen
[i
] < how
)
542 static int match_pathspec_with_flags(struct index_state
*istate
,
543 const struct pathspec
*ps
,
544 const char *name
, int namelen
,
545 int prefix
, char *seen
, unsigned flags
)
547 int positive
, negative
;
548 positive
= do_match_pathspec(istate
, ps
, name
, namelen
,
549 prefix
, seen
, flags
);
550 if (!(ps
->magic
& PATHSPEC_EXCLUDE
) || !positive
)
552 negative
= do_match_pathspec(istate
, ps
, name
, namelen
,
554 flags
| DO_MATCH_EXCLUDE
);
555 return negative
? 0 : positive
;
558 int match_pathspec(struct index_state
*istate
,
559 const struct pathspec
*ps
,
560 const char *name
, int namelen
,
561 int prefix
, char *seen
, int is_dir
)
563 unsigned flags
= is_dir
? DO_MATCH_DIRECTORY
: 0;
564 return match_pathspec_with_flags(istate
, ps
, name
, namelen
,
565 prefix
, seen
, flags
);
569 * Check if a submodule is a superset of the pathspec
571 int submodule_path_match(struct index_state
*istate
,
572 const struct pathspec
*ps
,
573 const char *submodule_name
,
576 int matched
= match_pathspec_with_flags(istate
, ps
, submodule_name
,
577 strlen(submodule_name
),
580 DO_MATCH_LEADING_PATHSPEC
);
584 int report_path_error(const char *ps_matched
,
585 const struct pathspec
*pathspec
)
588 * Make sure all pathspec matched; otherwise it is an error.
591 for (num
= 0; num
< pathspec
->nr
; num
++) {
592 int other
, found_dup
;
597 * The caller might have fed identical pathspec
598 * twice. Do not barf on such a mistake.
599 * FIXME: parse_pathspec should have eliminated
600 * duplicate pathspec.
602 for (found_dup
= other
= 0;
603 !found_dup
&& other
< pathspec
->nr
;
605 if (other
== num
|| !ps_matched
[other
])
607 if (!strcmp(pathspec
->items
[other
].original
,
608 pathspec
->items
[num
].original
))
610 * Ok, we have a match already.
617 error(_("pathspec '%s' did not match any file(s) known to git"),
618 pathspec
->items
[num
].original
);
625 * Return the length of the "simple" part of a path match limiter.
627 int simple_length(const char *match
)
632 unsigned char c
= *match
++;
634 if (c
== '\0' || is_glob_special(c
))
639 int no_wildcard(const char *string
)
641 return string
[simple_length(string
)] == '\0';
644 void parse_path_pattern(const char **pattern
,
649 const char *p
= *pattern
;
654 *flags
|= PATTERN_FLAG_NEGATIVE
;
658 if (len
&& p
[len
- 1] == '/') {
660 *flags
|= PATTERN_FLAG_MUSTBEDIR
;
662 for (i
= 0; i
< len
; i
++) {
667 *flags
|= PATTERN_FLAG_NODIR
;
668 *nowildcardlen
= simple_length(p
);
670 * we should have excluded the trailing slash from 'p' too,
671 * but that's one more allocation. Instead just make sure
672 * nowildcardlen does not exceed real patternlen
674 if (*nowildcardlen
> len
)
675 *nowildcardlen
= len
;
676 if (*p
== '*' && no_wildcard(p
+ 1))
677 *flags
|= PATTERN_FLAG_ENDSWITH
;
682 int pl_hashmap_cmp(const void *cmp_data UNUSED
,
683 const struct hashmap_entry
*a
,
684 const struct hashmap_entry
*b
,
685 const void *key UNUSED
)
687 const struct pattern_entry
*ee1
=
688 container_of(a
, struct pattern_entry
, ent
);
689 const struct pattern_entry
*ee2
=
690 container_of(b
, struct pattern_entry
, ent
);
692 size_t min_len
= ee1
->patternlen
<= ee2
->patternlen
696 return fspathncmp(ee1
->pattern
, ee2
->pattern
, min_len
);
699 static char *dup_and_filter_pattern(const char *pattern
)
703 char *result
= xstrdup(pattern
);
709 /* skip escape characters (once) */
729 static void clear_pattern_entry_hashmap(struct hashmap
*map
)
731 struct hashmap_iter iter
;
732 struct pattern_entry
*entry
;
734 hashmap_for_each_entry(map
, &iter
, entry
, ent
) {
735 free(entry
->pattern
);
737 hashmap_clear_and_free(map
, struct pattern_entry
, ent
);
740 static void add_pattern_to_hashsets(struct pattern_list
*pl
, struct path_pattern
*given
)
742 struct pattern_entry
*translated
;
745 const char *prev
, *cur
, *next
;
747 if (!pl
->use_cone_patterns
)
750 if (given
->flags
& PATTERN_FLAG_NEGATIVE
&&
751 given
->flags
& PATTERN_FLAG_MUSTBEDIR
&&
752 !strcmp(given
->pattern
, "/*")) {
757 if (!given
->flags
&& !strcmp(given
->pattern
, "/*")) {
762 if (given
->patternlen
< 2 ||
763 *given
->pattern
!= '/' ||
764 strstr(given
->pattern
, "**")) {
765 /* Not a cone pattern. */
766 warning(_("unrecognized pattern: '%s'"), given
->pattern
);
770 if (!(given
->flags
& PATTERN_FLAG_MUSTBEDIR
) &&
771 strcmp(given
->pattern
, "/*")) {
772 /* Not a cone pattern. */
773 warning(_("unrecognized pattern: '%s'"), given
->pattern
);
777 prev
= given
->pattern
;
778 cur
= given
->pattern
+ 1;
779 next
= given
->pattern
+ 2;
782 /* Watch for glob characters '*', '\', '[', '?' */
783 if (!is_glob_special(*cur
))
786 /* But only if *prev != '\\' */
790 /* But allow the initial '\' */
792 is_glob_special(*next
))
795 /* But a trailing '/' then '*' is fine */
801 /* Not a cone pattern. */
802 warning(_("unrecognized pattern: '%s'"), given
->pattern
);
811 if (given
->patternlen
> 2 &&
812 !strcmp(given
->pattern
+ given
->patternlen
- 2, "/*")) {
813 if (!(given
->flags
& PATTERN_FLAG_NEGATIVE
)) {
814 /* Not a cone pattern. */
815 warning(_("unrecognized pattern: '%s'"), given
->pattern
);
819 truncated
= dup_and_filter_pattern(given
->pattern
);
821 translated
= xmalloc(sizeof(struct pattern_entry
));
822 translated
->pattern
= truncated
;
823 translated
->patternlen
= given
->patternlen
- 2;
824 hashmap_entry_init(&translated
->ent
,
825 fspathhash(translated
->pattern
));
827 if (!hashmap_get_entry(&pl
->recursive_hashmap
,
828 translated
, ent
, NULL
)) {
829 /* We did not see the "parent" included */
830 warning(_("unrecognized negative pattern: '%s'"),
837 hashmap_add(&pl
->parent_hashmap
, &translated
->ent
);
838 hashmap_remove(&pl
->recursive_hashmap
, &translated
->ent
, &data
);
843 if (given
->flags
& PATTERN_FLAG_NEGATIVE
) {
844 warning(_("unrecognized negative pattern: '%s'"),
849 translated
= xmalloc(sizeof(struct pattern_entry
));
851 translated
->pattern
= dup_and_filter_pattern(given
->pattern
);
852 translated
->patternlen
= given
->patternlen
;
853 hashmap_entry_init(&translated
->ent
,
854 fspathhash(translated
->pattern
));
856 hashmap_add(&pl
->recursive_hashmap
, &translated
->ent
);
858 if (hashmap_get_entry(&pl
->parent_hashmap
, translated
, ent
, NULL
)) {
859 /* we already included this at the parent level */
860 warning(_("your sparse-checkout file may have issues: pattern '%s' is repeated"),
868 warning(_("disabling cone pattern matching"));
869 clear_pattern_entry_hashmap(&pl
->recursive_hashmap
);
870 clear_pattern_entry_hashmap(&pl
->parent_hashmap
);
871 pl
->use_cone_patterns
= 0;
874 static int hashmap_contains_path(struct hashmap
*map
,
875 struct strbuf
*pattern
)
877 struct pattern_entry p
;
879 /* Check straight mapping */
880 p
.pattern
= pattern
->buf
;
881 p
.patternlen
= pattern
->len
;
882 hashmap_entry_init(&p
.ent
, fspathhash(p
.pattern
));
883 return !!hashmap_get_entry(map
, &p
, ent
, NULL
);
886 int hashmap_contains_parent(struct hashmap
*map
,
888 struct strbuf
*buffer
)
892 strbuf_setlen(buffer
, 0);
895 strbuf_addch(buffer
, '/');
897 strbuf_addstr(buffer
, path
);
899 slash_pos
= strrchr(buffer
->buf
, '/');
901 while (slash_pos
> buffer
->buf
) {
902 strbuf_setlen(buffer
, slash_pos
- buffer
->buf
);
904 if (hashmap_contains_path(map
, buffer
))
907 slash_pos
= strrchr(buffer
->buf
, '/');
913 void add_pattern(const char *string
, const char *base
,
914 int baselen
, struct pattern_list
*pl
, int srcpos
)
916 struct path_pattern
*pattern
;
921 parse_path_pattern(&string
, &patternlen
, &flags
, &nowildcardlen
);
922 if (flags
& PATTERN_FLAG_MUSTBEDIR
) {
923 FLEXPTR_ALLOC_MEM(pattern
, pattern
, string
, patternlen
);
925 pattern
= xmalloc(sizeof(*pattern
));
926 pattern
->pattern
= string
;
928 pattern
->patternlen
= patternlen
;
929 pattern
->nowildcardlen
= nowildcardlen
;
930 pattern
->base
= base
;
931 pattern
->baselen
= baselen
;
932 pattern
->flags
= flags
;
933 pattern
->srcpos
= srcpos
;
934 ALLOC_GROW(pl
->patterns
, pl
->nr
+ 1, pl
->alloc
);
935 pl
->patterns
[pl
->nr
++] = pattern
;
938 add_pattern_to_hashsets(pl
, pattern
);
941 static int read_skip_worktree_file_from_index(struct index_state
*istate
,
943 size_t *size_out
, char **data_out
,
944 struct oid_stat
*oid_stat
)
949 pos
= index_name_pos(istate
, path
, len
);
952 if (!ce_skip_worktree(istate
->cache
[pos
]))
955 return do_read_blob(&istate
->cache
[pos
]->oid
, oid_stat
, size_out
, data_out
);
959 * Frees memory within pl which was allocated for exclude patterns and
960 * the file buffer. Does not free pl itself.
962 void clear_pattern_list(struct pattern_list
*pl
)
966 for (i
= 0; i
< pl
->nr
; i
++)
967 free(pl
->patterns
[i
]);
970 clear_pattern_entry_hashmap(&pl
->recursive_hashmap
);
971 clear_pattern_entry_hashmap(&pl
->parent_hashmap
);
973 memset(pl
, 0, sizeof(*pl
));
976 static void trim_trailing_spaces(char *buf
)
978 char *p
, *last_space
= NULL
;
980 for (p
= buf
; *p
; p
++)
1000 * Given a subdirectory name and "dir" of the current directory,
1001 * search the subdir in "dir" and return it, or create a new one if it
1002 * does not exist in "dir".
1004 * If "name" has the trailing slash, it'll be excluded in the search.
1006 static struct untracked_cache_dir
*lookup_untracked(struct untracked_cache
*uc
,
1007 struct untracked_cache_dir
*dir
,
1008 const char *name
, int len
)
1011 struct untracked_cache_dir
*d
;
1014 if (len
&& name
[len
- 1] == '/')
1017 last
= dir
->dirs_nr
;
1018 while (last
> first
) {
1019 int cmp
, next
= first
+ ((last
- first
) >> 1);
1020 d
= dir
->dirs
[next
];
1021 cmp
= strncmp(name
, d
->name
, len
);
1022 if (!cmp
&& strlen(d
->name
) > len
)
1034 FLEX_ALLOC_MEM(d
, name
, name
, len
);
1036 ALLOC_GROW(dir
->dirs
, dir
->dirs_nr
+ 1, dir
->dirs_alloc
);
1037 MOVE_ARRAY(dir
->dirs
+ first
+ 1, dir
->dirs
+ first
,
1038 dir
->dirs_nr
- first
);
1040 dir
->dirs
[first
] = d
;
1044 static void do_invalidate_gitignore(struct untracked_cache_dir
*dir
)
1048 dir
->untracked_nr
= 0;
1049 for (i
= 0; i
< dir
->dirs_nr
; i
++)
1050 do_invalidate_gitignore(dir
->dirs
[i
]);
1053 static void invalidate_gitignore(struct untracked_cache
*uc
,
1054 struct untracked_cache_dir
*dir
)
1056 uc
->gitignore_invalidated
++;
1057 do_invalidate_gitignore(dir
);
1060 static void invalidate_directory(struct untracked_cache
*uc
,
1061 struct untracked_cache_dir
*dir
)
1066 * Invalidation increment here is just roughly correct. If
1067 * untracked_nr or any of dirs[].recurse is non-zero, we
1068 * should increment dir_invalidated too. But that's more
1072 uc
->dir_invalidated
++;
1075 dir
->untracked_nr
= 0;
1076 for (i
= 0; i
< dir
->dirs_nr
; i
++)
1077 dir
->dirs
[i
]->recurse
= 0;
1080 static int add_patterns_from_buffer(char *buf
, size_t size
,
1081 const char *base
, int baselen
,
1082 struct pattern_list
*pl
);
1084 /* Flags for add_patterns() */
1085 #define PATTERN_NOFOLLOW (1<<0)
1088 * Given a file with name "fname", read it (either from disk, or from
1089 * an index if 'istate' is non-null), parse it and store the
1090 * exclude rules in "pl".
1092 * If "oid_stat" is not NULL, compute oid of the exclude file and fill
1093 * stat data from disk (only valid if add_patterns returns zero). If
1094 * oid_stat.valid is non-zero, "oid_stat" must contain good value as input.
1096 static int add_patterns(const char *fname
, const char *base
, int baselen
,
1097 struct pattern_list
*pl
, struct index_state
*istate
,
1098 unsigned flags
, struct oid_stat
*oid_stat
)
1106 if (flags
& PATTERN_NOFOLLOW
)
1107 fd
= open_nofollow(fname
, O_RDONLY
);
1109 fd
= open(fname
, O_RDONLY
);
1111 if (fd
< 0 || fstat(fd
, &st
) < 0) {
1113 warn_on_fopen_errors(fname
);
1118 r
= read_skip_worktree_file_from_index(istate
, fname
,
1124 size
= xsize_t(st
.st_size
);
1127 fill_stat_data(&oid_stat
->stat
, &st
);
1128 oidcpy(&oid_stat
->oid
, the_hash_algo
->empty_blob
);
1129 oid_stat
->valid
= 1;
1134 buf
= xmallocz(size
);
1135 if (read_in_full(fd
, buf
, size
) != size
) {
1144 if (oid_stat
->valid
&&
1145 !match_stat_data_racy(istate
, &oid_stat
->stat
, &st
))
1146 ; /* no content change, oid_stat->oid still good */
1148 (pos
= index_name_pos(istate
, fname
, strlen(fname
))) >= 0 &&
1149 !ce_stage(istate
->cache
[pos
]) &&
1150 ce_uptodate(istate
->cache
[pos
]) &&
1151 !would_convert_to_git(istate
, fname
))
1152 oidcpy(&oid_stat
->oid
,
1153 &istate
->cache
[pos
]->oid
);
1155 hash_object_file(the_hash_algo
, buf
, size
,
1156 OBJ_BLOB
, &oid_stat
->oid
);
1157 fill_stat_data(&oid_stat
->stat
, &st
);
1158 oid_stat
->valid
= 1;
1162 add_patterns_from_buffer(buf
, size
, base
, baselen
, pl
);
1166 static int add_patterns_from_buffer(char *buf
, size_t size
,
1167 const char *base
, int baselen
,
1168 struct pattern_list
*pl
)
1173 hashmap_init(&pl
->recursive_hashmap
, pl_hashmap_cmp
, NULL
, 0);
1174 hashmap_init(&pl
->parent_hashmap
, pl_hashmap_cmp
, NULL
, 0);
1178 if (skip_utf8_bom(&buf
, size
))
1179 size
-= buf
- pl
->filebuf
;
1183 for (i
= 0; i
< size
; i
++) {
1184 if (buf
[i
] == '\n') {
1185 if (entry
!= buf
+ i
&& entry
[0] != '#') {
1186 buf
[i
- (i
&& buf
[i
-1] == '\r')] = 0;
1187 trim_trailing_spaces(entry
);
1188 add_pattern(entry
, base
, baselen
, pl
, lineno
);
1191 entry
= buf
+ i
+ 1;
1197 int add_patterns_from_file_to_list(const char *fname
, const char *base
,
1198 int baselen
, struct pattern_list
*pl
,
1199 struct index_state
*istate
,
1202 return add_patterns(fname
, base
, baselen
, pl
, istate
, flags
, NULL
);
1205 int add_patterns_from_blob_to_list(
1206 struct object_id
*oid
,
1207 const char *base
, int baselen
,
1208 struct pattern_list
*pl
)
1214 r
= do_read_blob(oid
, NULL
, &size
, &buf
);
1218 add_patterns_from_buffer(buf
, size
, base
, baselen
, pl
);
1222 struct pattern_list
*add_pattern_list(struct dir_struct
*dir
,
1223 int group_type
, const char *src
)
1225 struct pattern_list
*pl
;
1226 struct exclude_list_group
*group
;
1228 group
= &dir
->internal
.exclude_list_group
[group_type
];
1229 ALLOC_GROW(group
->pl
, group
->nr
+ 1, group
->alloc
);
1230 pl
= &group
->pl
[group
->nr
++];
1231 memset(pl
, 0, sizeof(*pl
));
1237 * Used to set up core.excludesfile and .git/info/exclude lists.
1239 static void add_patterns_from_file_1(struct dir_struct
*dir
, const char *fname
,
1240 struct oid_stat
*oid_stat
)
1242 struct pattern_list
*pl
;
1244 * catch setup_standard_excludes() that's called before
1245 * dir->untracked is assigned. That function behaves
1246 * differently when dir->untracked is non-NULL.
1248 if (!dir
->untracked
)
1249 dir
->internal
.unmanaged_exclude_files
++;
1250 pl
= add_pattern_list(dir
, EXC_FILE
, fname
);
1251 if (add_patterns(fname
, "", 0, pl
, NULL
, 0, oid_stat
) < 0)
1252 die(_("cannot use %s as an exclude file"), fname
);
1255 void add_patterns_from_file(struct dir_struct
*dir
, const char *fname
)
1257 dir
->internal
.unmanaged_exclude_files
++; /* see validate_untracked_cache() */
1258 add_patterns_from_file_1(dir
, fname
, NULL
);
1261 int match_basename(const char *basename
, int basenamelen
,
1262 const char *pattern
, int prefix
, int patternlen
,
1265 if (prefix
== patternlen
) {
1266 if (patternlen
== basenamelen
&&
1267 !fspathncmp(pattern
, basename
, basenamelen
))
1269 } else if (flags
& PATTERN_FLAG_ENDSWITH
) {
1270 /* "*literal" matching against "fooliteral" */
1271 if (patternlen
- 1 <= basenamelen
&&
1272 !fspathncmp(pattern
+ 1,
1273 basename
+ basenamelen
- (patternlen
- 1),
1277 if (fnmatch_icase_mem(pattern
, patternlen
,
1278 basename
, basenamelen
,
1285 int match_pathname(const char *pathname
, int pathlen
,
1286 const char *base
, int baselen
,
1287 const char *pattern
, int prefix
, int patternlen
)
1293 * match with FNM_PATHNAME; the pattern has base implicitly
1296 if (*pattern
== '/') {
1303 * baselen does not count the trailing slash. base[] may or
1304 * may not end with a trailing slash though.
1306 if (pathlen
< baselen
+ 1 ||
1307 (baselen
&& pathname
[baselen
] != '/') ||
1308 fspathncmp(pathname
, base
, baselen
))
1311 namelen
= baselen
? pathlen
- baselen
- 1 : pathlen
;
1312 name
= pathname
+ pathlen
- namelen
;
1316 * if the non-wildcard part is longer than the
1317 * remaining pathname, surely it cannot match.
1319 if (prefix
> namelen
)
1322 if (fspathncmp(pattern
, name
, prefix
))
1325 patternlen
-= prefix
;
1330 * If the whole pattern did not have a wildcard,
1331 * then our prefix match is all we need; we
1332 * do not need to call fnmatch at all.
1334 if (!patternlen
&& !namelen
)
1338 return fnmatch_icase_mem(pattern
, patternlen
,
1344 * Scan the given exclude list in reverse to see whether pathname
1345 * should be ignored. The first match (i.e. the last on the list), if
1346 * any, determines the fate. Returns the exclude_list element which
1347 * matched, or NULL for undecided.
1349 static struct path_pattern
*last_matching_pattern_from_list(const char *pathname
,
1351 const char *basename
,
1353 struct pattern_list
*pl
,
1354 struct index_state
*istate
)
1356 struct path_pattern
*res
= NULL
; /* undecided */
1360 return NULL
; /* undefined */
1362 for (i
= pl
->nr
- 1; 0 <= i
; i
--) {
1363 struct path_pattern
*pattern
= pl
->patterns
[i
];
1364 const char *exclude
= pattern
->pattern
;
1365 int prefix
= pattern
->nowildcardlen
;
1367 if (pattern
->flags
& PATTERN_FLAG_MUSTBEDIR
) {
1368 *dtype
= resolve_dtype(*dtype
, istate
, pathname
, pathlen
);
1369 if (*dtype
!= DT_DIR
)
1373 if (pattern
->flags
& PATTERN_FLAG_NODIR
) {
1374 if (match_basename(basename
,
1375 pathlen
- (basename
- pathname
),
1376 exclude
, prefix
, pattern
->patternlen
,
1384 assert(pattern
->baselen
== 0 ||
1385 pattern
->base
[pattern
->baselen
- 1] == '/');
1386 if (match_pathname(pathname
, pathlen
,
1388 pattern
->baselen
? pattern
->baselen
- 1 : 0,
1389 exclude
, prefix
, pattern
->patternlen
)) {
1398 * Scan the list of patterns to determine if the ordered list
1399 * of patterns matches on 'pathname'.
1401 * Return 1 for a match, 0 for not matched and -1 for undecided.
1403 enum pattern_match_result
path_matches_pattern_list(
1404 const char *pathname
, int pathlen
,
1405 const char *basename
, int *dtype
,
1406 struct pattern_list
*pl
,
1407 struct index_state
*istate
)
1409 struct path_pattern
*pattern
;
1410 struct strbuf parent_pathname
= STRBUF_INIT
;
1411 int result
= NOT_MATCHED
;
1414 if (!pl
->use_cone_patterns
) {
1415 pattern
= last_matching_pattern_from_list(pathname
, pathlen
, basename
,
1418 if (pattern
->flags
& PATTERN_FLAG_NEGATIVE
)
1430 strbuf_addch(&parent_pathname
, '/');
1431 strbuf_add(&parent_pathname
, pathname
, pathlen
);
1434 * Directory entries are matched if and only if a file
1435 * contained immediately within them is matched. For the
1436 * case of a directory entry, modify the path to create
1437 * a fake filename within this directory, allowing us to
1438 * use the file-base matching logic in an equivalent way.
1440 if (parent_pathname
.len
> 0 &&
1441 parent_pathname
.buf
[parent_pathname
.len
- 1] == '/') {
1442 slash_pos
= parent_pathname
.len
- 1;
1443 strbuf_add(&parent_pathname
, "-", 1);
1445 const char *slash_ptr
= strrchr(parent_pathname
.buf
, '/');
1446 slash_pos
= slash_ptr
? slash_ptr
- parent_pathname
.buf
: 0;
1449 if (hashmap_contains_path(&pl
->recursive_hashmap
,
1450 &parent_pathname
)) {
1451 result
= MATCHED_RECURSIVE
;
1456 /* include every file in root */
1461 strbuf_setlen(&parent_pathname
, slash_pos
);
1463 if (hashmap_contains_path(&pl
->parent_hashmap
, &parent_pathname
)) {
1468 if (hashmap_contains_parent(&pl
->recursive_hashmap
,
1471 result
= MATCHED_RECURSIVE
;
1474 strbuf_release(&parent_pathname
);
1478 int init_sparse_checkout_patterns(struct index_state
*istate
)
1480 if (!core_apply_sparse_checkout
)
1482 if (istate
->sparse_checkout_patterns
)
1485 CALLOC_ARRAY(istate
->sparse_checkout_patterns
, 1);
1487 if (get_sparse_checkout_patterns(istate
->sparse_checkout_patterns
) < 0) {
1488 FREE_AND_NULL(istate
->sparse_checkout_patterns
);
1495 static int path_in_sparse_checkout_1(const char *path
,
1496 struct index_state
*istate
,
1497 int require_cone_mode
)
1500 enum pattern_match_result match
= UNDECIDED
;
1501 const char *end
, *slash
;
1504 * We default to accepting a path if the path is empty, there are no
1505 * patterns, or the patterns are of the wrong type.
1508 init_sparse_checkout_patterns(istate
) ||
1509 (require_cone_mode
&&
1510 !istate
->sparse_checkout_patterns
->use_cone_patterns
))
1514 * If UNDECIDED, use the match from the parent dir (recursively), or
1515 * fall back to NOT_MATCHED at the topmost level. Note that cone mode
1516 * never returns UNDECIDED, so we will execute only one iteration in
1519 for (end
= path
+ strlen(path
);
1520 end
> path
&& match
== UNDECIDED
;
1523 for (slash
= end
- 1; slash
> path
&& *slash
!= '/'; slash
--)
1526 match
= path_matches_pattern_list(path
, end
- path
,
1527 slash
> path
? slash
+ 1 : path
, &dtype
,
1528 istate
->sparse_checkout_patterns
, istate
);
1530 /* We are going to match the parent dir now */
1536 int path_in_sparse_checkout(const char *path
,
1537 struct index_state
*istate
)
1539 return path_in_sparse_checkout_1(path
, istate
, 0);
1542 int path_in_cone_mode_sparse_checkout(const char *path
,
1543 struct index_state
*istate
)
1545 return path_in_sparse_checkout_1(path
, istate
, 1);
1548 static struct path_pattern
*last_matching_pattern_from_lists(
1549 struct dir_struct
*dir
, struct index_state
*istate
,
1550 const char *pathname
, int pathlen
,
1551 const char *basename
, int *dtype_p
)
1554 struct exclude_list_group
*group
;
1555 struct path_pattern
*pattern
;
1556 for (i
= EXC_CMDL
; i
<= EXC_FILE
; i
++) {
1557 group
= &dir
->internal
.exclude_list_group
[i
];
1558 for (j
= group
->nr
- 1; j
>= 0; j
--) {
1559 pattern
= last_matching_pattern_from_list(
1560 pathname
, pathlen
, basename
, dtype_p
,
1561 &group
->pl
[j
], istate
);
1570 * Loads the per-directory exclude list for the substring of base
1571 * which has a char length of baselen.
1573 static void prep_exclude(struct dir_struct
*dir
,
1574 struct index_state
*istate
,
1575 const char *base
, int baselen
)
1577 struct exclude_list_group
*group
;
1578 struct pattern_list
*pl
;
1579 struct exclude_stack
*stk
= NULL
;
1580 struct untracked_cache_dir
*untracked
;
1583 group
= &dir
->internal
.exclude_list_group
[EXC_DIRS
];
1586 * Pop the exclude lists from the EXCL_DIRS exclude_list_group
1587 * which originate from directories not in the prefix of the
1588 * path being checked.
1590 while ((stk
= dir
->internal
.exclude_stack
) != NULL
) {
1591 if (stk
->baselen
<= baselen
&&
1592 !strncmp(dir
->internal
.basebuf
.buf
, base
, stk
->baselen
))
1594 pl
= &group
->pl
[dir
->internal
.exclude_stack
->exclude_ix
];
1595 dir
->internal
.exclude_stack
= stk
->prev
;
1596 dir
->internal
.pattern
= NULL
;
1597 free((char *)pl
->src
); /* see strbuf_detach() below */
1598 clear_pattern_list(pl
);
1603 /* Skip traversing into sub directories if the parent is excluded */
1604 if (dir
->internal
.pattern
)
1608 * Lazy initialization. All call sites currently just
1609 * memset(dir, 0, sizeof(*dir)) before use. Changing all of
1610 * them seems lots of work for little benefit.
1612 if (!dir
->internal
.basebuf
.buf
)
1613 strbuf_init(&dir
->internal
.basebuf
, PATH_MAX
);
1615 /* Read from the parent directories and push them down. */
1616 current
= stk
? stk
->baselen
: -1;
1617 strbuf_setlen(&dir
->internal
.basebuf
, current
< 0 ? 0 : current
);
1619 untracked
= stk
? stk
->ucd
: dir
->untracked
->root
;
1623 while (current
< baselen
) {
1625 struct oid_stat oid_stat
;
1627 CALLOC_ARRAY(stk
, 1);
1632 cp
= strchr(base
+ current
+ 1, '/');
1634 die("oops in prep_exclude");
1637 lookup_untracked(dir
->untracked
,
1640 cp
- base
- current
);
1642 stk
->prev
= dir
->internal
.exclude_stack
;
1643 stk
->baselen
= cp
- base
;
1644 stk
->exclude_ix
= group
->nr
;
1645 stk
->ucd
= untracked
;
1646 pl
= add_pattern_list(dir
, EXC_DIRS
, NULL
);
1647 strbuf_add(&dir
->internal
.basebuf
, base
+ current
, stk
->baselen
- current
);
1648 assert(stk
->baselen
== dir
->internal
.basebuf
.len
);
1650 /* Abort if the directory is excluded */
1653 dir
->internal
.basebuf
.buf
[stk
->baselen
- 1] = 0;
1654 dir
->internal
.pattern
= last_matching_pattern_from_lists(dir
,
1656 dir
->internal
.basebuf
.buf
, stk
->baselen
- 1,
1657 dir
->internal
.basebuf
.buf
+ current
, &dt
);
1658 dir
->internal
.basebuf
.buf
[stk
->baselen
- 1] = '/';
1659 if (dir
->internal
.pattern
&&
1660 dir
->internal
.pattern
->flags
& PATTERN_FLAG_NEGATIVE
)
1661 dir
->internal
.pattern
= NULL
;
1662 if (dir
->internal
.pattern
) {
1663 dir
->internal
.exclude_stack
= stk
;
1668 /* Try to read per-directory file */
1669 oidclr(&oid_stat
.oid
);
1671 if (dir
->exclude_per_dir
&&
1673 * If we know that no files have been added in
1674 * this directory (i.e. valid_cached_dir() has
1675 * been executed and set untracked->valid) ..
1677 (!untracked
|| !untracked
->valid
||
1679 * .. and .gitignore does not exist before
1680 * (i.e. null exclude_oid). Then we can skip
1681 * loading .gitignore, which would result in
1684 !is_null_oid(&untracked
->exclude_oid
))) {
1686 * dir->internal.basebuf gets reused by the traversal,
1687 * but we need fname to remain unchanged to ensure the
1688 * src member of each struct path_pattern correctly
1689 * back-references its source file. Other invocations
1690 * of add_pattern_list provide stable strings, so we
1691 * strbuf_detach() and free() here in the caller.
1693 struct strbuf sb
= STRBUF_INIT
;
1694 strbuf_addbuf(&sb
, &dir
->internal
.basebuf
);
1695 strbuf_addstr(&sb
, dir
->exclude_per_dir
);
1696 pl
->src
= strbuf_detach(&sb
, NULL
);
1697 add_patterns(pl
->src
, pl
->src
, stk
->baselen
, pl
, istate
,
1699 untracked
? &oid_stat
: NULL
);
1702 * NEEDSWORK: when untracked cache is enabled, prep_exclude()
1703 * will first be called in valid_cached_dir() then maybe many
1704 * times more in last_matching_pattern(). When the cache is
1705 * used, last_matching_pattern() will not be called and
1706 * reading .gitignore content will be a waste.
1708 * So when it's called by valid_cached_dir() and we can get
1709 * .gitignore SHA-1 from the index (i.e. .gitignore is not
1710 * modified on work tree), we could delay reading the
1711 * .gitignore content until we absolutely need it in
1712 * last_matching_pattern(). Be careful about ignore rule
1713 * order, though, if you do that.
1716 !oideq(&oid_stat
.oid
, &untracked
->exclude_oid
)) {
1717 invalidate_gitignore(dir
->untracked
, untracked
);
1718 oidcpy(&untracked
->exclude_oid
, &oid_stat
.oid
);
1720 dir
->internal
.exclude_stack
= stk
;
1721 current
= stk
->baselen
;
1723 strbuf_setlen(&dir
->internal
.basebuf
, baselen
);
1727 * Loads the exclude lists for the directory containing pathname, then
1728 * scans all exclude lists to determine whether pathname is excluded.
1729 * Returns the exclude_list element which matched, or NULL for
1732 struct path_pattern
*last_matching_pattern(struct dir_struct
*dir
,
1733 struct index_state
*istate
,
1734 const char *pathname
,
1737 int pathlen
= strlen(pathname
);
1738 const char *basename
= strrchr(pathname
, '/');
1739 basename
= (basename
) ? basename
+1 : pathname
;
1741 prep_exclude(dir
, istate
, pathname
, basename
-pathname
);
1743 if (dir
->internal
.pattern
)
1744 return dir
->internal
.pattern
;
1746 return last_matching_pattern_from_lists(dir
, istate
, pathname
, pathlen
,
1751 * Loads the exclude lists for the directory containing pathname, then
1752 * scans all exclude lists to determine whether pathname is excluded.
1753 * Returns 1 if true, otherwise 0.
1755 int is_excluded(struct dir_struct
*dir
, struct index_state
*istate
,
1756 const char *pathname
, int *dtype_p
)
1758 struct path_pattern
*pattern
=
1759 last_matching_pattern(dir
, istate
, pathname
, dtype_p
);
1761 return pattern
->flags
& PATTERN_FLAG_NEGATIVE
? 0 : 1;
1765 static struct dir_entry
*dir_entry_new(const char *pathname
, int len
)
1767 struct dir_entry
*ent
;
1769 FLEX_ALLOC_MEM(ent
, name
, pathname
, len
);
1774 static struct dir_entry
*dir_add_name(struct dir_struct
*dir
,
1775 struct index_state
*istate
,
1776 const char *pathname
, int len
)
1778 if (index_file_exists(istate
, pathname
, len
, ignore_case
))
1781 ALLOC_GROW(dir
->entries
, dir
->nr
+1, dir
->internal
.alloc
);
1782 return dir
->entries
[dir
->nr
++] = dir_entry_new(pathname
, len
);
1785 struct dir_entry
*dir_add_ignored(struct dir_struct
*dir
,
1786 struct index_state
*istate
,
1787 const char *pathname
, int len
)
1789 if (!index_name_is_other(istate
, pathname
, len
))
1792 ALLOC_GROW(dir
->ignored
, dir
->ignored_nr
+1, dir
->internal
.ignored_alloc
);
1793 return dir
->ignored
[dir
->ignored_nr
++] = dir_entry_new(pathname
, len
);
1797 index_nonexistent
= 0,
1803 * Do not use the alphabetically sorted index to look up
1804 * the directory name; instead, use the case insensitive
1807 static enum exist_status
directory_exists_in_index_icase(struct index_state
*istate
,
1808 const char *dirname
, int len
)
1810 struct cache_entry
*ce
;
1812 if (index_dir_exists(istate
, dirname
, len
))
1813 return index_directory
;
1815 ce
= index_file_exists(istate
, dirname
, len
, ignore_case
);
1816 if (ce
&& S_ISGITLINK(ce
->ce_mode
))
1817 return index_gitdir
;
1819 return index_nonexistent
;
1823 * The index sorts alphabetically by entry name, which
1824 * means that a gitlink sorts as '\0' at the end, while
1825 * a directory (which is defined not as an entry, but as
1826 * the files it contains) will sort with the '/' at the
1829 static enum exist_status
directory_exists_in_index(struct index_state
*istate
,
1830 const char *dirname
, int len
)
1835 return directory_exists_in_index_icase(istate
, dirname
, len
);
1837 pos
= index_name_pos(istate
, dirname
, len
);
1840 while (pos
< istate
->cache_nr
) {
1841 const struct cache_entry
*ce
= istate
->cache
[pos
++];
1842 unsigned char endchar
;
1844 if (strncmp(ce
->name
, dirname
, len
))
1846 endchar
= ce
->name
[len
];
1850 return index_directory
;
1851 if (!endchar
&& S_ISGITLINK(ce
->ce_mode
))
1852 return index_gitdir
;
1854 return index_nonexistent
;
1858 * When we find a directory when traversing the filesystem, we
1859 * have three distinct cases:
1862 * - see it as a directory
1865 * and which one we choose depends on a combination of existing
1866 * git index contents and the flags passed into the directory
1867 * traversal routine.
1869 * Case 1: If we *already* have entries in the index under that
1870 * directory name, we always recurse into the directory to see
1873 * Case 2: If we *already* have that directory name as a gitlink,
1874 * we always continue to see it as a gitlink, regardless of whether
1875 * there is an actual git directory there or not (it might not
1876 * be checked out as a subproject!)
1878 * Case 3: if we didn't have it in the index previously, we
1879 * have a few sub-cases:
1881 * (a) if DIR_SHOW_OTHER_DIRECTORIES flag is set, we show it as
1882 * just a directory, unless DIR_HIDE_EMPTY_DIRECTORIES is
1883 * also true, in which case we need to check if it contains any
1884 * untracked and / or ignored files.
1885 * (b) if it looks like a git directory and we don't have the
1886 * DIR_NO_GITLINKS flag, then we treat it as a gitlink, and
1887 * show it as a directory.
1888 * (c) otherwise, we recurse into it.
1890 static enum path_treatment
treat_directory(struct dir_struct
*dir
,
1891 struct index_state
*istate
,
1892 struct untracked_cache_dir
*untracked
,
1893 const char *dirname
, int len
, int baselen
, int excluded
,
1894 const struct pathspec
*pathspec
)
1897 * WARNING: From this function, you can return path_recurse or you
1898 * can call read_directory_recursive() (or neither), but
1899 * you CAN'T DO BOTH.
1901 enum path_treatment state
;
1902 int matches_how
= 0;
1903 int check_only
, stop_early
;
1904 int old_ignored_nr
, old_untracked_nr
;
1905 /* The "len-1" is to strip the final '/' */
1906 enum exist_status status
= directory_exists_in_index(istate
, dirname
, len
-1);
1908 if (status
== index_directory
)
1909 return path_recurse
;
1910 if (status
== index_gitdir
)
1912 if (status
!= index_nonexistent
)
1913 BUG("Unhandled value for directory_exists_in_index: %d\n", status
);
1916 * We don't want to descend into paths that don't match the necessary
1917 * patterns. Clearly, if we don't have a pathspec, then we can't check
1918 * for matching patterns. Also, if (excluded) then we know we matched
1919 * the exclusion patterns so as an optimization we can skip checking
1920 * for matching patterns.
1922 if (pathspec
&& !excluded
) {
1923 matches_how
= match_pathspec_with_flags(istate
, pathspec
,
1927 DO_MATCH_LEADING_PATHSPEC
);
1933 if ((dir
->flags
& DIR_SKIP_NESTED_GIT
) ||
1934 !(dir
->flags
& DIR_NO_GITLINKS
)) {
1936 * Determine if `dirname` is a nested repo by confirming that:
1937 * 1) we are in a nonbare repository, and
1938 * 2) `dirname` is not an immediate parent of `the_repository->gitdir`,
1939 * which could occur if the git_dir or worktree location was
1940 * manually configured by the user; see t2205 testcases 1-3 for
1941 * examples where this matters
1944 struct strbuf sb
= STRBUF_INIT
;
1945 strbuf_addstr(&sb
, dirname
);
1946 nested_repo
= is_nonbare_repository_dir(&sb
);
1949 char *real_dirname
, *real_gitdir
;
1950 strbuf_addstr(&sb
, ".git");
1951 real_dirname
= real_pathdup(sb
.buf
, 1);
1952 real_gitdir
= real_pathdup(the_repository
->gitdir
, 1);
1954 nested_repo
= !!strcmp(real_dirname
, real_gitdir
);
1958 strbuf_release(&sb
);
1961 if ((dir
->flags
& DIR_SKIP_NESTED_GIT
) ||
1962 (matches_how
== MATCHED_RECURSIVELY_LEADING_PATHSPEC
))
1964 return excluded
? path_excluded
: path_untracked
;
1968 if (!(dir
->flags
& DIR_SHOW_OTHER_DIRECTORIES
)) {
1970 (dir
->flags
& DIR_SHOW_IGNORED_TOO
) &&
1971 (dir
->flags
& DIR_SHOW_IGNORED_TOO_MODE_MATCHING
)) {
1974 * This is an excluded directory and we are
1975 * showing ignored paths that match an exclude
1976 * pattern. (e.g. show directory as ignored
1977 * only if it matches an exclude pattern).
1978 * This path will either be 'path_excluded`
1979 * (if we are showing empty directories or if
1980 * the directory is not empty), or will be
1981 * 'path_none' (empty directory, and we are
1982 * not showing empty directories).
1984 if (!(dir
->flags
& DIR_HIDE_EMPTY_DIRECTORIES
))
1985 return path_excluded
;
1987 if (read_directory_recursive(dir
, istate
, dirname
, len
,
1988 untracked
, 1, 1, pathspec
) == path_excluded
)
1989 return path_excluded
;
1993 return path_recurse
;
1996 assert(dir
->flags
& DIR_SHOW_OTHER_DIRECTORIES
);
1999 * If we have a pathspec which could match something _below_ this
2000 * directory (e.g. when checking 'subdir/' having a pathspec like
2001 * 'subdir/some/deep/path/file' or 'subdir/widget-*.c'), then we
2004 if (matches_how
== MATCHED_RECURSIVELY_LEADING_PATHSPEC
)
2005 return path_recurse
;
2007 /* Special cases for where this directory is excluded/ignored */
2010 * If DIR_SHOW_OTHER_DIRECTORIES is set and we're not
2011 * hiding empty directories, there is no need to
2012 * recurse into an ignored directory.
2014 if (!(dir
->flags
& DIR_HIDE_EMPTY_DIRECTORIES
))
2015 return path_excluded
;
2018 * Even if we are hiding empty directories, we can still avoid
2019 * recursing into ignored directories for DIR_SHOW_IGNORED_TOO
2020 * if DIR_SHOW_IGNORED_TOO_MODE_MATCHING is also set.
2022 if ((dir
->flags
& DIR_SHOW_IGNORED_TOO
) &&
2023 (dir
->flags
& DIR_SHOW_IGNORED_TOO_MODE_MATCHING
))
2024 return path_excluded
;
2028 * Other than the path_recurse case above, we only need to
2029 * recurse into untracked directories if any of the following
2031 * - DIR_SHOW_IGNORED (because then we need to determine if
2032 * there are ignored entries below)
2033 * - DIR_SHOW_IGNORED_TOO (same as above)
2034 * - DIR_HIDE_EMPTY_DIRECTORIES (because we have to determine if
2035 * the directory is empty)
2038 !(dir
->flags
& (DIR_SHOW_IGNORED
|
2039 DIR_SHOW_IGNORED_TOO
|
2040 DIR_HIDE_EMPTY_DIRECTORIES
))) {
2041 return path_untracked
;
2045 * Even if we don't want to know all the paths under an untracked or
2046 * ignored directory, we may still need to go into the directory to
2047 * determine if it is empty (because with DIR_HIDE_EMPTY_DIRECTORIES,
2048 * an empty directory should be path_none instead of path_excluded or
2051 check_only
= ((dir
->flags
& DIR_HIDE_EMPTY_DIRECTORIES
) &&
2052 !(dir
->flags
& DIR_SHOW_IGNORED_TOO
));
2055 * However, there's another optimization possible as a subset of
2056 * check_only, based on the cases we have to consider:
2057 * A) Directory matches no exclude patterns:
2058 * * Directory is empty => path_none
2059 * * Directory has an untracked file under it => path_untracked
2060 * * Directory has only ignored files under it => path_excluded
2061 * B) Directory matches an exclude pattern:
2062 * * Directory is empty => path_none
2063 * * Directory has an untracked file under it => path_excluded
2064 * * Directory has only ignored files under it => path_excluded
2065 * In case A, we can exit as soon as we've found an untracked
2066 * file but otherwise have to walk all files. In case B, though,
2067 * we can stop at the first file we find under the directory.
2069 stop_early
= check_only
&& excluded
;
2072 * If /every/ file within an untracked directory is ignored, then
2073 * we want to treat the directory as ignored (for e.g. status
2074 * --porcelain), without listing the individual ignored files
2075 * underneath. To do so, we'll save the current ignored_nr, and
2076 * pop all the ones added after it if it turns out the entire
2077 * directory is ignored. Also, when DIR_SHOW_IGNORED_TOO and
2078 * !DIR_KEEP_UNTRACKED_CONTENTS then we don't want to show
2079 * untracked paths so will need to pop all those off the last
2080 * after we traverse.
2082 old_ignored_nr
= dir
->ignored_nr
;
2083 old_untracked_nr
= dir
->nr
;
2085 /* Actually recurse into dirname now, we'll fixup the state later. */
2086 untracked
= lookup_untracked(dir
->untracked
, untracked
,
2087 dirname
+ baselen
, len
- baselen
);
2088 state
= read_directory_recursive(dir
, istate
, dirname
, len
, untracked
,
2089 check_only
, stop_early
, pathspec
);
2091 /* There are a variety of reasons we may need to fixup the state... */
2092 if (state
== path_excluded
) {
2093 /* state == path_excluded implies all paths under
2094 * dirname were ignored...
2096 * if running e.g. `git status --porcelain --ignored=matching`,
2097 * then we want to see the subpaths that are ignored.
2099 * if running e.g. just `git status --porcelain`, then
2100 * we just want the directory itself to be listed as ignored
2101 * and not the individual paths underneath.
2103 int want_ignored_subpaths
=
2104 ((dir
->flags
& DIR_SHOW_IGNORED_TOO
) &&
2105 (dir
->flags
& DIR_SHOW_IGNORED_TOO_MODE_MATCHING
));
2107 if (want_ignored_subpaths
) {
2109 * with --ignored=matching, we want the subpaths
2110 * INSTEAD of the directory itself.
2115 for (i
= old_ignored_nr
+ 1; i
<dir
->ignored_nr
; ++i
)
2116 FREE_AND_NULL(dir
->ignored
[i
]);
2117 dir
->ignored_nr
= old_ignored_nr
;
2122 * We may need to ignore some of the untracked paths we found while
2123 * traversing subdirectories.
2125 if ((dir
->flags
& DIR_SHOW_IGNORED_TOO
) &&
2126 !(dir
->flags
& DIR_KEEP_UNTRACKED_CONTENTS
)) {
2128 for (i
= old_untracked_nr
+ 1; i
<dir
->nr
; ++i
)
2129 FREE_AND_NULL(dir
->entries
[i
]);
2130 dir
->nr
= old_untracked_nr
;
2134 * If there is nothing under the current directory and we are not
2135 * hiding empty directories, then we need to report on the
2136 * untracked or ignored status of the directory itself.
2138 if (state
== path_none
&& !(dir
->flags
& DIR_HIDE_EMPTY_DIRECTORIES
))
2139 state
= excluded
? path_excluded
: path_untracked
;
2145 * This is an inexact early pruning of any recursive directory
2146 * reading - if the path cannot possibly be in the pathspec,
2147 * return true, and we'll skip it early.
2149 static int simplify_away(const char *path
, int pathlen
,
2150 const struct pathspec
*pathspec
)
2154 if (!pathspec
|| !pathspec
->nr
)
2157 GUARD_PATHSPEC(pathspec
,
2166 for (i
= 0; i
< pathspec
->nr
; i
++) {
2167 const struct pathspec_item
*item
= &pathspec
->items
[i
];
2168 int len
= item
->nowildcard_len
;
2172 if (!ps_strncmp(item
, item
->match
, path
, len
))
2180 * This function tells us whether an excluded path matches a
2181 * list of "interesting" pathspecs. That is, whether a path matched
2182 * by any of the pathspecs could possibly be ignored by excluding
2183 * the specified path. This can happen if:
2185 * 1. the path is mentioned explicitly in the pathspec
2187 * 2. the path is a directory prefix of some element in the
2190 static int exclude_matches_pathspec(const char *path
, int pathlen
,
2191 const struct pathspec
*pathspec
)
2195 if (!pathspec
|| !pathspec
->nr
)
2198 GUARD_PATHSPEC(pathspec
,
2207 for (i
= 0; i
< pathspec
->nr
; i
++) {
2208 const struct pathspec_item
*item
= &pathspec
->items
[i
];
2209 int len
= item
->nowildcard_len
;
2211 if (len
== pathlen
&&
2212 !ps_strncmp(item
, item
->match
, path
, pathlen
))
2214 if (len
> pathlen
&&
2215 item
->match
[pathlen
] == '/' &&
2216 !ps_strncmp(item
, item
->match
, path
, pathlen
))
2222 static int get_index_dtype(struct index_state
*istate
,
2223 const char *path
, int len
)
2226 const struct cache_entry
*ce
;
2228 ce
= index_file_exists(istate
, path
, len
, 0);
2230 if (!ce_uptodate(ce
))
2232 if (S_ISGITLINK(ce
->ce_mode
))
2235 * Nobody actually cares about the
2236 * difference between DT_LNK and DT_REG
2241 /* Try to look it up as a directory */
2242 pos
= index_name_pos(istate
, path
, len
);
2246 while (pos
< istate
->cache_nr
) {
2247 ce
= istate
->cache
[pos
++];
2248 if (strncmp(ce
->name
, path
, len
))
2250 if (ce
->name
[len
] > '/')
2252 if (ce
->name
[len
] < '/')
2254 if (!ce_uptodate(ce
))
2255 break; /* continue? */
2261 unsigned char get_dtype(struct dirent
*e
, struct strbuf
*path
,
2265 unsigned char dtype
= DTYPE(e
);
2266 size_t base_path_len
;
2268 if (dtype
!= DT_UNKNOWN
&& !(follow_symlink
&& dtype
== DT_LNK
))
2272 * d_type unknown or unfollowed symlink, try to fall back on [l]stat
2273 * results. If [l]stat fails, explicitly set DT_UNKNOWN.
2275 base_path_len
= path
->len
;
2276 strbuf_addstr(path
, e
->d_name
);
2277 if ((follow_symlink
&& stat(path
->buf
, &st
)) ||
2278 (!follow_symlink
&& lstat(path
->buf
, &st
)))
2281 /* determine d_type from st_mode */
2282 if (S_ISREG(st
.st_mode
))
2284 else if (S_ISDIR(st
.st_mode
))
2286 else if (S_ISLNK(st
.st_mode
))
2290 strbuf_setlen(path
, base_path_len
);
2294 static int resolve_dtype(int dtype
, struct index_state
*istate
,
2295 const char *path
, int len
)
2299 if (dtype
!= DT_UNKNOWN
)
2301 dtype
= get_index_dtype(istate
, path
, len
);
2302 if (dtype
!= DT_UNKNOWN
)
2304 if (lstat(path
, &st
))
2306 if (S_ISREG(st
.st_mode
))
2308 if (S_ISDIR(st
.st_mode
))
2310 if (S_ISLNK(st
.st_mode
))
2315 static enum path_treatment
treat_path_fast(struct dir_struct
*dir
,
2316 struct cached_dir
*cdir
,
2317 struct index_state
*istate
,
2318 struct strbuf
*path
,
2320 const struct pathspec
*pathspec
)
2323 * WARNING: From this function, you can return path_recurse or you
2324 * can call read_directory_recursive() (or neither), but
2325 * you CAN'T DO BOTH.
2327 strbuf_setlen(path
, baselen
);
2329 strbuf_addstr(path
, cdir
->file
);
2330 return path_untracked
;
2332 strbuf_addstr(path
, cdir
->ucd
->name
);
2333 /* treat_one_path() does this before it calls treat_directory() */
2334 strbuf_complete(path
, '/');
2335 if (cdir
->ucd
->check_only
)
2337 * check_only is set as a result of treat_directory() getting
2338 * to its bottom. Verify again the same set of directories
2339 * with check_only set.
2341 return read_directory_recursive(dir
, istate
, path
->buf
, path
->len
,
2342 cdir
->ucd
, 1, 0, pathspec
);
2344 * We get path_recurse in the first run when
2345 * directory_exists_in_index() returns index_nonexistent. We
2346 * are sure that new changes in the index does not impact the
2347 * outcome. Return now.
2349 return path_recurse
;
2352 static enum path_treatment
treat_path(struct dir_struct
*dir
,
2353 struct untracked_cache_dir
*untracked
,
2354 struct cached_dir
*cdir
,
2355 struct index_state
*istate
,
2356 struct strbuf
*path
,
2358 const struct pathspec
*pathspec
)
2360 int has_path_in_index
, dtype
, excluded
;
2363 return treat_path_fast(dir
, cdir
, istate
, path
,
2365 if (is_dot_or_dotdot(cdir
->d_name
) || !fspathcmp(cdir
->d_name
, ".git"))
2367 strbuf_setlen(path
, baselen
);
2368 strbuf_addstr(path
, cdir
->d_name
);
2369 if (simplify_away(path
->buf
, path
->len
, pathspec
))
2372 dtype
= resolve_dtype(cdir
->d_type
, istate
, path
->buf
, path
->len
);
2374 /* Always exclude indexed files */
2375 has_path_in_index
= !!index_file_exists(istate
, path
->buf
, path
->len
,
2377 if (dtype
!= DT_DIR
&& has_path_in_index
)
2381 * When we are looking at a directory P in the working tree,
2382 * there are three cases:
2384 * (1) P exists in the index. Everything inside the directory P in
2385 * the working tree needs to go when P is checked out from the
2388 * (2) P does not exist in the index, but there is P/Q in the index.
2389 * We know P will stay a directory when we check out the contents
2390 * of the index, but we do not know yet if there is a directory
2391 * P/Q in the working tree to be killed, so we need to recurse.
2393 * (3) P does not exist in the index, and there is no P/Q in the index
2394 * to require P to be a directory, either. Only in this case, we
2395 * know that everything inside P will not be killed without
2398 if ((dir
->flags
& DIR_COLLECT_KILLED_ONLY
) &&
2399 (dtype
== DT_DIR
) &&
2400 !has_path_in_index
&&
2401 (directory_exists_in_index(istate
, path
->buf
, path
->len
) == index_nonexistent
))
2404 excluded
= is_excluded(dir
, istate
, path
->buf
, &dtype
);
2407 * Excluded? If we don't explicitly want to show
2408 * ignored files, ignore it
2410 if (excluded
&& !(dir
->flags
& (DIR_SHOW_IGNORED
|DIR_SHOW_IGNORED_TOO
)))
2411 return path_excluded
;
2418 * WARNING: Do not ignore/amend the return value from
2419 * treat_directory(), and especially do not change it to return
2420 * path_recurse as that can cause exponential slowdown.
2421 * Instead, modify treat_directory() to return the right value.
2423 strbuf_addch(path
, '/');
2424 return treat_directory(dir
, istate
, untracked
,
2425 path
->buf
, path
->len
,
2426 baselen
, excluded
, pathspec
);
2430 !match_pathspec(istate
, pathspec
, path
->buf
, path
->len
,
2431 0 /* prefix */, NULL
/* seen */,
2435 return path_excluded
;
2436 return path_untracked
;
2440 static void add_untracked(struct untracked_cache_dir
*dir
, const char *name
)
2444 ALLOC_GROW(dir
->untracked
, dir
->untracked_nr
+ 1,
2445 dir
->untracked_alloc
);
2446 dir
->untracked
[dir
->untracked_nr
++] = xstrdup(name
);
2449 static int valid_cached_dir(struct dir_struct
*dir
,
2450 struct untracked_cache_dir
*untracked
,
2451 struct index_state
*istate
,
2452 struct strbuf
*path
,
2461 * With fsmonitor, we can trust the untracked cache's valid field.
2463 refresh_fsmonitor(istate
);
2464 if (!(dir
->untracked
->use_fsmonitor
&& untracked
->valid
)) {
2465 if (lstat(path
->len
? path
->buf
: ".", &st
)) {
2466 memset(&untracked
->stat_data
, 0, sizeof(untracked
->stat_data
));
2469 if (!untracked
->valid
||
2470 match_stat_data_racy(istate
, &untracked
->stat_data
, &st
)) {
2471 fill_stat_data(&untracked
->stat_data
, &st
);
2476 if (untracked
->check_only
!= !!check_only
)
2480 * prep_exclude will be called eventually on this directory,
2481 * but it's called much later in last_matching_pattern(). We
2482 * need it now to determine the validity of the cache for this
2483 * path. The next calls will be nearly no-op, the way
2484 * prep_exclude() is designed.
2486 if (path
->len
&& path
->buf
[path
->len
- 1] != '/') {
2487 strbuf_addch(path
, '/');
2488 prep_exclude(dir
, istate
, path
->buf
, path
->len
);
2489 strbuf_setlen(path
, path
->len
- 1);
2491 prep_exclude(dir
, istate
, path
->buf
, path
->len
);
2493 /* hopefully prep_exclude() haven't invalidated this entry... */
2494 return untracked
->valid
;
2497 static int open_cached_dir(struct cached_dir
*cdir
,
2498 struct dir_struct
*dir
,
2499 struct untracked_cache_dir
*untracked
,
2500 struct index_state
*istate
,
2501 struct strbuf
*path
,
2506 memset(cdir
, 0, sizeof(*cdir
));
2507 cdir
->untracked
= untracked
;
2508 if (valid_cached_dir(dir
, untracked
, istate
, path
, check_only
))
2510 c_path
= path
->len
? path
->buf
: ".";
2511 cdir
->fdir
= opendir(c_path
);
2513 warning_errno(_("could not open directory '%s'"), c_path
);
2514 if (dir
->untracked
) {
2515 invalidate_directory(dir
->untracked
, untracked
);
2516 dir
->untracked
->dir_opened
++;
2523 static int read_cached_dir(struct cached_dir
*cdir
)
2528 de
= readdir_skip_dot_and_dotdot(cdir
->fdir
);
2530 cdir
->d_name
= NULL
;
2531 cdir
->d_type
= DT_UNKNOWN
;
2534 cdir
->d_name
= de
->d_name
;
2535 cdir
->d_type
= DTYPE(de
);
2538 while (cdir
->nr_dirs
< cdir
->untracked
->dirs_nr
) {
2539 struct untracked_cache_dir
*d
= cdir
->untracked
->dirs
[cdir
->nr_dirs
];
2549 if (cdir
->nr_files
< cdir
->untracked
->untracked_nr
) {
2550 struct untracked_cache_dir
*d
= cdir
->untracked
;
2551 cdir
->file
= d
->untracked
[cdir
->nr_files
++];
2557 static void close_cached_dir(struct cached_dir
*cdir
)
2560 closedir(cdir
->fdir
);
2562 * We have gone through this directory and found no untracked
2563 * entries. Mark it valid.
2565 if (cdir
->untracked
) {
2566 cdir
->untracked
->valid
= 1;
2567 cdir
->untracked
->recurse
= 1;
2571 static void add_path_to_appropriate_result_list(struct dir_struct
*dir
,
2572 struct untracked_cache_dir
*untracked
,
2573 struct cached_dir
*cdir
,
2574 struct index_state
*istate
,
2575 struct strbuf
*path
,
2577 const struct pathspec
*pathspec
,
2578 enum path_treatment state
)
2580 /* add the path to the appropriate result list */
2583 if (dir
->flags
& DIR_SHOW_IGNORED
)
2584 dir_add_name(dir
, istate
, path
->buf
, path
->len
);
2585 else if ((dir
->flags
& DIR_SHOW_IGNORED_TOO
) ||
2586 ((dir
->flags
& DIR_COLLECT_IGNORED
) &&
2587 exclude_matches_pathspec(path
->buf
, path
->len
,
2589 dir_add_ignored(dir
, istate
, path
->buf
, path
->len
);
2592 case path_untracked
:
2593 if (dir
->flags
& DIR_SHOW_IGNORED
)
2595 dir_add_name(dir
, istate
, path
->buf
, path
->len
);
2597 add_untracked(untracked
, path
->buf
+ baselen
);
2606 * Read a directory tree. We currently ignore anything but
2607 * directories, regular files and symlinks. That's because git
2608 * doesn't handle them at all yet. Maybe that will change some
2611 * Also, we ignore the name ".git" (even if it is not a directory).
2612 * That likely will not change.
2614 * If 'stop_at_first_file' is specified, 'path_excluded' is returned
2615 * to signal that a file was found. This is the least significant value that
2616 * indicates that a file was encountered that does not depend on the order of
2617 * whether an untracked or excluded path was encountered first.
2619 * Returns the most significant path_treatment value encountered in the scan.
2620 * If 'stop_at_first_file' is specified, `path_excluded` is the most
2621 * significant path_treatment value that will be returned.
2624 static enum path_treatment
read_directory_recursive(struct dir_struct
*dir
,
2625 struct index_state
*istate
, const char *base
, int baselen
,
2626 struct untracked_cache_dir
*untracked
, int check_only
,
2627 int stop_at_first_file
, const struct pathspec
*pathspec
)
2630 * WARNING: Do NOT recurse unless path_recurse is returned from
2631 * treat_path(). Recursing on any other return value
2632 * can result in exponential slowdown.
2634 struct cached_dir cdir
;
2635 enum path_treatment state
, subdir_state
, dir_state
= path_none
;
2636 struct strbuf path
= STRBUF_INIT
;
2638 strbuf_add(&path
, base
, baselen
);
2640 if (open_cached_dir(&cdir
, dir
, untracked
, istate
, &path
, check_only
))
2642 dir
->internal
.visited_directories
++;
2645 untracked
->check_only
= !!check_only
;
2647 while (!read_cached_dir(&cdir
)) {
2648 /* check how the file or directory should be treated */
2649 state
= treat_path(dir
, untracked
, &cdir
, istate
, &path
,
2651 dir
->internal
.visited_paths
++;
2653 if (state
> dir_state
)
2656 /* recurse into subdir if instructed by treat_path */
2657 if (state
== path_recurse
) {
2658 struct untracked_cache_dir
*ud
;
2659 ud
= lookup_untracked(dir
->untracked
,
2662 path
.len
- baselen
);
2664 read_directory_recursive(dir
, istate
, path
.buf
,
2666 check_only
, stop_at_first_file
, pathspec
);
2667 if (subdir_state
> dir_state
)
2668 dir_state
= subdir_state
;
2671 !match_pathspec(istate
, pathspec
, path
.buf
, path
.len
,
2672 0 /* prefix */, NULL
,
2673 0 /* do NOT special case dirs */))
2678 if (stop_at_first_file
) {
2680 * If stopping at first file, then
2681 * signal that a file was found by
2682 * returning `path_excluded`. This is
2683 * to return a consistent value
2684 * regardless of whether an ignored or
2685 * excluded file happened to be
2688 * In current usage, the
2689 * `stop_at_first_file` is passed when
2690 * an ancestor directory has matched
2691 * an exclude pattern, so any found
2692 * files will be excluded.
2694 if (dir_state
>= path_excluded
) {
2695 dir_state
= path_excluded
;
2700 /* abort early if maximum state has been reached */
2701 if (dir_state
== path_untracked
) {
2703 add_untracked(untracked
, path
.buf
+ baselen
);
2706 /* skip the add_path_to_appropriate_result_list() */
2710 add_path_to_appropriate_result_list(dir
, untracked
, &cdir
,
2711 istate
, &path
, baselen
,
2714 close_cached_dir(&cdir
);
2716 strbuf_release(&path
);
2721 int cmp_dir_entry(const void *p1
, const void *p2
)
2723 const struct dir_entry
*e1
= *(const struct dir_entry
**)p1
;
2724 const struct dir_entry
*e2
= *(const struct dir_entry
**)p2
;
2726 return name_compare(e1
->name
, e1
->len
, e2
->name
, e2
->len
);
2729 /* check if *out lexically strictly contains *in */
2730 int check_dir_entry_contains(const struct dir_entry
*out
, const struct dir_entry
*in
)
2732 return (out
->len
< in
->len
) &&
2733 (out
->name
[out
->len
- 1] == '/') &&
2734 !memcmp(out
->name
, in
->name
, out
->len
);
2737 static int treat_leading_path(struct dir_struct
*dir
,
2738 struct index_state
*istate
,
2739 const char *path
, int len
,
2740 const struct pathspec
*pathspec
)
2742 struct strbuf sb
= STRBUF_INIT
;
2743 struct strbuf subdir
= STRBUF_INIT
;
2744 int prevlen
, baselen
;
2746 struct cached_dir cdir
;
2747 enum path_treatment state
= path_none
;
2750 * For each directory component of path, we are going to check whether
2751 * that path is relevant given the pathspec. For example, if path is
2753 * then we will ask treat_path() whether we should go into foo, then
2754 * whether we should go into bar, then whether baz is relevant.
2755 * Checking each is important because e.g. if path is
2757 * then we need to check .git to know we shouldn't traverse it.
2758 * If the return from treat_path() is:
2759 * * path_none, for any path, we return false.
2760 * * path_recurse, for all path components, we return true
2761 * * <anything else> for some intermediate component, we make sure
2762 * to add that path to the relevant list but return false
2763 * signifying that we shouldn't recurse into it.
2766 while (len
&& path
[len
- 1] == '/')
2771 memset(&cdir
, 0, sizeof(cdir
));
2772 cdir
.d_type
= DT_DIR
;
2776 prevlen
= baselen
+ !!baselen
;
2777 cp
= path
+ prevlen
;
2778 cp
= memchr(cp
, '/', path
+ len
- cp
);
2782 baselen
= cp
- path
;
2784 strbuf_add(&sb
, path
, baselen
);
2785 if (!is_directory(sb
.buf
))
2788 strbuf_add(&sb
, path
, prevlen
);
2789 strbuf_reset(&subdir
);
2790 strbuf_add(&subdir
, path
+prevlen
, baselen
-prevlen
);
2791 cdir
.d_name
= subdir
.buf
;
2792 state
= treat_path(dir
, NULL
, &cdir
, istate
, &sb
, prevlen
, pathspec
);
2794 if (state
!= path_recurse
)
2795 break; /* do not recurse into it */
2797 break; /* finished checking */
2799 add_path_to_appropriate_result_list(dir
, NULL
, &cdir
, istate
,
2800 &sb
, baselen
, pathspec
,
2803 strbuf_release(&subdir
);
2804 strbuf_release(&sb
);
2805 return state
== path_recurse
;
2808 static const char *get_ident_string(void)
2810 static struct strbuf sb
= STRBUF_INIT
;
2815 if (uname(&uts
) < 0)
2816 die_errno(_("failed to get kernel name and information"));
2817 strbuf_addf(&sb
, "Location %s, system %s", get_git_work_tree(),
2822 static int ident_in_untracked(const struct untracked_cache
*uc
)
2825 * Previous git versions may have saved many NUL separated
2826 * strings in the "ident" field, but it is insane to manage
2827 * many locations, so just take care of the first one.
2830 return !strcmp(uc
->ident
.buf
, get_ident_string());
2833 static void set_untracked_ident(struct untracked_cache
*uc
)
2835 strbuf_reset(&uc
->ident
);
2836 strbuf_addstr(&uc
->ident
, get_ident_string());
2839 * This strbuf used to contain a list of NUL separated
2840 * strings, so save NUL too for backward compatibility.
2842 strbuf_addch(&uc
->ident
, 0);
2845 static unsigned new_untracked_cache_flags(struct index_state
*istate
)
2847 struct repository
*repo
= istate
->repo
;
2851 * This logic is coordinated with the setting of these flags in
2852 * wt-status.c#wt_status_collect_untracked(), and the evaluation
2853 * of the config setting in commit.c#git_status_config()
2855 if (!repo_config_get_string(repo
, "status.showuntrackedfiles", &val
) &&
2856 !strcmp(val
, "all"))
2860 * The default, if "all" is not set, is "normal" - leading us here.
2861 * If the value is "none" then it really doesn't matter.
2863 return DIR_SHOW_OTHER_DIRECTORIES
| DIR_HIDE_EMPTY_DIRECTORIES
;
2866 static void new_untracked_cache(struct index_state
*istate
, int flags
)
2868 struct untracked_cache
*uc
= xcalloc(1, sizeof(*uc
));
2869 strbuf_init(&uc
->ident
, 100);
2870 uc
->exclude_per_dir
= ".gitignore";
2871 uc
->dir_flags
= flags
>= 0 ? flags
: new_untracked_cache_flags(istate
);
2872 set_untracked_ident(uc
);
2873 istate
->untracked
= uc
;
2874 istate
->cache_changed
|= UNTRACKED_CHANGED
;
2877 void add_untracked_cache(struct index_state
*istate
)
2879 if (!istate
->untracked
) {
2880 new_untracked_cache(istate
, -1);
2882 if (!ident_in_untracked(istate
->untracked
)) {
2883 free_untracked_cache(istate
->untracked
);
2884 new_untracked_cache(istate
, -1);
2889 void remove_untracked_cache(struct index_state
*istate
)
2891 if (istate
->untracked
) {
2892 free_untracked_cache(istate
->untracked
);
2893 istate
->untracked
= NULL
;
2894 istate
->cache_changed
|= UNTRACKED_CHANGED
;
2898 static struct untracked_cache_dir
*validate_untracked_cache(struct dir_struct
*dir
,
2900 const struct pathspec
*pathspec
,
2901 struct index_state
*istate
)
2903 struct untracked_cache_dir
*root
;
2904 static int untracked_cache_disabled
= -1;
2906 if (!dir
->untracked
)
2908 if (untracked_cache_disabled
< 0)
2909 untracked_cache_disabled
= git_env_bool("GIT_DISABLE_UNTRACKED_CACHE", 0);
2910 if (untracked_cache_disabled
)
2914 * We only support $GIT_DIR/info/exclude and core.excludesfile
2915 * as the global ignore rule files. Any other additions
2916 * (e.g. from command line) invalidate the cache. This
2917 * condition also catches running setup_standard_excludes()
2918 * before setting dir->untracked!
2920 if (dir
->internal
.unmanaged_exclude_files
)
2924 * Optimize for the main use case only: whole-tree git
2925 * status. More work involved in treat_leading_path() if we
2926 * use cache on just a subset of the worktree. pathspec
2927 * support could make the matter even worse.
2929 if (base_len
|| (pathspec
&& pathspec
->nr
))
2932 /* We don't support collecting ignore files */
2933 if (dir
->flags
& (DIR_SHOW_IGNORED
| DIR_SHOW_IGNORED_TOO
|
2934 DIR_COLLECT_IGNORED
))
2938 * If we use .gitignore in the cache and now you change it to
2939 * .gitexclude, everything will go wrong.
2941 if (dir
->exclude_per_dir
!= dir
->untracked
->exclude_per_dir
&&
2942 strcmp(dir
->exclude_per_dir
, dir
->untracked
->exclude_per_dir
))
2946 * EXC_CMDL is not considered in the cache. If people set it,
2949 if (dir
->internal
.exclude_list_group
[EXC_CMDL
].nr
)
2952 if (!ident_in_untracked(dir
->untracked
)) {
2953 warning(_("untracked cache is disabled on this system or location"));
2958 * If the untracked structure we received does not have the same flags
2959 * as requested in this run, we're going to need to either discard the
2960 * existing structure (and potentially later recreate), or bypass the
2961 * untracked cache mechanism for this run.
2963 if (dir
->flags
!= dir
->untracked
->dir_flags
) {
2965 * If the untracked structure we received does not have the same flags
2966 * as configured, then we need to reset / create a new "untracked"
2967 * structure to match the new config.
2969 * Keeping the saved and used untracked cache consistent with the
2970 * configuration provides an opportunity for frequent users of
2971 * "git status -uall" to leverage the untracked cache by aligning their
2972 * configuration - setting "status.showuntrackedfiles" to "all" or
2973 * "normal" as appropriate.
2975 * Previously using -uall (or setting "status.showuntrackedfiles" to
2976 * "all") was incompatible with untracked cache and *consistently*
2977 * caused surprisingly bad performance (with fscache and fsmonitor
2978 * enabled) on Windows.
2980 * IMPROVEMENT OPPORTUNITY: If we reworked the untracked cache storage
2981 * to not be as bound up with the desired output in a given run,
2982 * and instead iterated through and stored enough information to
2983 * correctly serve both "modes", then users could get peak performance
2984 * with or without '-uall' regardless of their
2985 * "status.showuntrackedfiles" config.
2987 if (dir
->untracked
->dir_flags
!= new_untracked_cache_flags(istate
)) {
2988 free_untracked_cache(istate
->untracked
);
2989 new_untracked_cache(istate
, dir
->flags
);
2990 dir
->untracked
= istate
->untracked
;
2994 * Current untracked cache data is consistent with config, but not
2995 * usable in this request/run; just bypass untracked cache.
3001 if (!dir
->untracked
->root
) {
3002 /* Untracked cache existed but is not initialized; fix that */
3003 FLEX_ALLOC_STR(dir
->untracked
->root
, name
, "");
3004 istate
->cache_changed
|= UNTRACKED_CHANGED
;
3007 /* Validate $GIT_DIR/info/exclude and core.excludesfile */
3008 root
= dir
->untracked
->root
;
3009 if (!oideq(&dir
->internal
.ss_info_exclude
.oid
,
3010 &dir
->untracked
->ss_info_exclude
.oid
)) {
3011 invalidate_gitignore(dir
->untracked
, root
);
3012 dir
->untracked
->ss_info_exclude
= dir
->internal
.ss_info_exclude
;
3014 if (!oideq(&dir
->internal
.ss_excludes_file
.oid
,
3015 &dir
->untracked
->ss_excludes_file
.oid
)) {
3016 invalidate_gitignore(dir
->untracked
, root
);
3017 dir
->untracked
->ss_excludes_file
= dir
->internal
.ss_excludes_file
;
3020 /* Make sure this directory is not dropped out at saving phase */
3025 static void emit_traversal_statistics(struct dir_struct
*dir
,
3026 struct repository
*repo
,
3030 if (!trace2_is_enabled())
3034 trace2_data_string("read_directory", repo
, "path", "");
3036 struct strbuf tmp
= STRBUF_INIT
;
3037 strbuf_add(&tmp
, path
, path_len
);
3038 trace2_data_string("read_directory", repo
, "path", tmp
.buf
);
3039 strbuf_release(&tmp
);
3042 trace2_data_intmax("read_directory", repo
,
3043 "directories-visited", dir
->internal
.visited_directories
);
3044 trace2_data_intmax("read_directory", repo
,
3045 "paths-visited", dir
->internal
.visited_paths
);
3047 if (!dir
->untracked
)
3049 trace2_data_intmax("read_directory", repo
,
3050 "node-creation", dir
->untracked
->dir_created
);
3051 trace2_data_intmax("read_directory", repo
,
3052 "gitignore-invalidation",
3053 dir
->untracked
->gitignore_invalidated
);
3054 trace2_data_intmax("read_directory", repo
,
3055 "directory-invalidation",
3056 dir
->untracked
->dir_invalidated
);
3057 trace2_data_intmax("read_directory", repo
,
3058 "opendir", dir
->untracked
->dir_opened
);
3061 int read_directory(struct dir_struct
*dir
, struct index_state
*istate
,
3062 const char *path
, int len
, const struct pathspec
*pathspec
)
3064 struct untracked_cache_dir
*untracked
;
3066 trace2_region_enter("dir", "read_directory", istate
->repo
);
3067 dir
->internal
.visited_paths
= 0;
3068 dir
->internal
.visited_directories
= 0;
3070 if (has_symlink_leading_path(path
, len
)) {
3071 trace2_region_leave("dir", "read_directory", istate
->repo
);
3075 untracked
= validate_untracked_cache(dir
, len
, pathspec
, istate
);
3078 * make sure untracked cache code path is disabled,
3079 * e.g. prep_exclude()
3081 dir
->untracked
= NULL
;
3082 if (!len
|| treat_leading_path(dir
, istate
, path
, len
, pathspec
))
3083 read_directory_recursive(dir
, istate
, path
, len
, untracked
, 0, 0, pathspec
);
3084 QSORT(dir
->entries
, dir
->nr
, cmp_dir_entry
);
3085 QSORT(dir
->ignored
, dir
->ignored_nr
, cmp_dir_entry
);
3087 emit_traversal_statistics(dir
, istate
->repo
, path
, len
);
3089 trace2_region_leave("dir", "read_directory", istate
->repo
);
3090 if (dir
->untracked
) {
3091 static int force_untracked_cache
= -1;
3093 if (force_untracked_cache
< 0)
3094 force_untracked_cache
=
3095 git_env_bool("GIT_FORCE_UNTRACKED_CACHE", -1);
3096 if (force_untracked_cache
< 0)
3097 force_untracked_cache
= (istate
->repo
->settings
.core_untracked_cache
== UNTRACKED_CACHE_WRITE
);
3098 if (force_untracked_cache
&&
3099 dir
->untracked
== istate
->untracked
&&
3100 (dir
->untracked
->dir_opened
||
3101 dir
->untracked
->gitignore_invalidated
||
3102 dir
->untracked
->dir_invalidated
))
3103 istate
->cache_changed
|= UNTRACKED_CHANGED
;
3104 if (dir
->untracked
!= istate
->untracked
) {
3105 FREE_AND_NULL(dir
->untracked
);
3112 int file_exists(const char *f
)
3115 return lstat(f
, &sb
) == 0;
3118 int repo_file_exists(struct repository
*repo
, const char *path
)
3120 if (repo
!= the_repository
)
3121 BUG("do not know how to check file existence in arbitrary repo");
3123 return file_exists(path
);
3126 static int cmp_icase(char a
, char b
)
3131 return toupper(a
) - toupper(b
);
3136 * Given two normalized paths (a trailing slash is ok), if subdir is
3137 * outside dir, return -1. Otherwise return the offset in subdir that
3138 * can be used as relative path to dir.
3140 int dir_inside_of(const char *subdir
, const char *dir
)
3144 assert(dir
&& subdir
&& *dir
&& *subdir
);
3146 while (*dir
&& *subdir
&& !cmp_icase(*dir
, *subdir
)) {
3152 /* hel[p]/me vs hel[l]/yeah */
3153 if (*dir
&& *subdir
)
3157 return !*dir
? offset
: -1; /* same dir */
3159 /* foo/[b]ar vs foo/[] */
3160 if (is_dir_sep(dir
[-1]))
3161 return is_dir_sep(subdir
[-1]) ? offset
: -1;
3163 /* foo[/]bar vs foo[] */
3164 return is_dir_sep(*subdir
) ? offset
+ 1 : -1;
3167 int is_inside_dir(const char *dir
)
3176 rc
= (dir_inside_of(cwd
, dir
) >= 0);
3181 int is_empty_dir(const char *path
)
3183 DIR *dir
= opendir(path
);
3190 e
= readdir_skip_dot_and_dotdot(dir
);
3198 char *git_url_basename(const char *repo
, int is_bundle
, int is_bare
)
3200 const char *end
= repo
+ strlen(repo
), *start
, *ptr
;
3207 start
= strstr(repo
, "://");
3214 * Skip authentication data. The stripping does happen
3215 * greedily, such that we strip up to the last '@' inside
3218 for (ptr
= start
; ptr
< end
&& !is_dir_sep(*ptr
); ptr
++) {
3224 * Strip trailing spaces, slashes and /.git
3226 while (start
< end
&& (is_dir_sep(end
[-1]) || isspace(end
[-1])))
3228 if (end
- start
> 5 && is_dir_sep(end
[-5]) &&
3229 !strncmp(end
- 4, ".git", 4)) {
3231 while (start
< end
&& is_dir_sep(end
[-1]))
3236 * It should not be possible to overflow `ptrdiff_t` by passing in an
3237 * insanely long URL, but GCC does not know that and will complain
3238 * without this check.
3240 if (end
- start
< 0)
3241 die(_("No directory name could be guessed.\n"
3242 "Please specify a directory on the command line"));
3245 * Strip trailing port number if we've got only a
3246 * hostname (that is, there is no dir separator but a
3247 * colon). This check is required such that we do not
3248 * strip URI's like '/foo/bar:2222.git', which should
3249 * result in a dir '2222' being guessed due to backwards
3252 if (memchr(start
, '/', end
- start
) == NULL
3253 && memchr(start
, ':', end
- start
) != NULL
) {
3255 while (start
< ptr
&& isdigit(ptr
[-1]) && ptr
[-1] != ':')
3257 if (start
< ptr
&& ptr
[-1] == ':')
3262 * Find last component. To remain backwards compatible we
3263 * also regard colons as path separators, such that
3264 * cloning a repository 'foo:bar.git' would result in a
3265 * directory 'bar' being guessed.
3268 while (start
< ptr
&& !is_dir_sep(ptr
[-1]) && ptr
[-1] != ':')
3273 * Strip .{bundle,git}.
3276 strip_suffix_mem(start
, &len
, is_bundle
? ".bundle" : ".git");
3278 if (!len
|| (len
== 1 && *start
== '/'))
3279 die(_("No directory name could be guessed.\n"
3280 "Please specify a directory on the command line"));
3283 dir
= xstrfmt("%.*s.git", (int)len
, start
);
3285 dir
= xstrndup(start
, len
);
3287 * Replace sequences of 'control' characters and whitespace
3288 * with one ascii space, remove leading and trailing spaces.
3292 int prev_space
= 1 /* strip leading whitespace */;
3293 for (end
= dir
; *end
; ++end
) {
3295 if ((unsigned char)ch
< '\x20')
3306 if (out
> dir
&& prev_space
)
3312 void strip_dir_trailing_slashes(char *dir
)
3314 char *end
= dir
+ strlen(dir
);
3316 while (dir
< end
- 1 && is_dir_sep(end
[-1]))
3321 static int remove_dir_recurse(struct strbuf
*path
, int flag
, int *kept_up
)
3325 int ret
= 0, original_len
= path
->len
, len
, kept_down
= 0;
3326 int only_empty
= (flag
& REMOVE_DIR_EMPTY_ONLY
);
3327 int keep_toplevel
= (flag
& REMOVE_DIR_KEEP_TOPLEVEL
);
3328 int purge_original_cwd
= (flag
& REMOVE_DIR_PURGE_ORIGINAL_CWD
);
3329 struct object_id submodule_head
;
3331 if ((flag
& REMOVE_DIR_KEEP_NESTED_GIT
) &&
3332 !resolve_gitlink_ref(path
->buf
, "HEAD", &submodule_head
)) {
3333 /* Do not descend and nuke a nested git work tree. */
3339 flag
&= ~REMOVE_DIR_KEEP_TOPLEVEL
;
3340 dir
= opendir(path
->buf
);
3342 if (errno
== ENOENT
)
3343 return keep_toplevel
? -1 : 0;
3344 else if (errno
== EACCES
&& !keep_toplevel
)
3346 * An empty dir could be removable even if it
3349 return rmdir(path
->buf
);
3353 strbuf_complete(path
, '/');
3356 while ((e
= readdir_skip_dot_and_dotdot(dir
)) != NULL
) {
3359 strbuf_setlen(path
, len
);
3360 strbuf_addstr(path
, e
->d_name
);
3361 if (lstat(path
->buf
, &st
)) {
3362 if (errno
== ENOENT
)
3364 * file disappeared, which is what we
3369 } else if (S_ISDIR(st
.st_mode
)) {
3370 if (!remove_dir_recurse(path
, flag
, &kept_down
))
3371 continue; /* happy */
3372 } else if (!only_empty
&&
3373 (!unlink(path
->buf
) || errno
== ENOENT
)) {
3374 continue; /* happy, too */
3377 /* path too long, stat fails, or non-directory still exists */
3383 strbuf_setlen(path
, original_len
);
3384 if (!ret
&& !keep_toplevel
&& !kept_down
) {
3385 if (!purge_original_cwd
&&
3386 startup_info
->original_cwd
&&
3387 !strcmp(startup_info
->original_cwd
, path
->buf
))
3388 ret
= -1; /* Do not remove current working directory */
3390 ret
= (!rmdir(path
->buf
) || errno
== ENOENT
) ? 0 : -1;
3393 * report the uplevel that it is not an error that we
3394 * did not rmdir() our directory.
3400 int remove_dir_recursively(struct strbuf
*path
, int flag
)
3402 return remove_dir_recurse(path
, flag
, NULL
);
3405 static GIT_PATH_FUNC(git_path_info_exclude
, "info/exclude")
3407 void setup_standard_excludes(struct dir_struct
*dir
)
3409 dir
->exclude_per_dir
= ".gitignore";
3411 /* core.excludesfile defaulting to $XDG_CONFIG_HOME/git/ignore */
3413 excludes_file
= xdg_config_home("ignore");
3414 if (excludes_file
&& !access_or_warn(excludes_file
, R_OK
, 0))
3415 add_patterns_from_file_1(dir
, excludes_file
,
3416 dir
->untracked
? &dir
->internal
.ss_excludes_file
: NULL
);
3418 /* per repository user preference */
3419 if (startup_info
->have_repository
) {
3420 const char *path
= git_path_info_exclude();
3421 if (!access_or_warn(path
, R_OK
, 0))
3422 add_patterns_from_file_1(dir
, path
,
3423 dir
->untracked
? &dir
->internal
.ss_info_exclude
: NULL
);
3427 char *get_sparse_checkout_filename(void)
3429 return git_pathdup("info/sparse-checkout");
3432 int get_sparse_checkout_patterns(struct pattern_list
*pl
)
3435 char *sparse_filename
= get_sparse_checkout_filename();
3437 pl
->use_cone_patterns
= core_sparse_checkout_cone
;
3438 res
= add_patterns_from_file_to_list(sparse_filename
, "", 0, pl
, NULL
, 0);
3440 free(sparse_filename
);
3444 int remove_path(const char *name
)
3448 if (unlink(name
) && !is_missing_file_error(errno
))
3451 slash
= strrchr(name
, '/');
3453 char *dirs
= xstrdup(name
);
3454 slash
= dirs
+ (slash
- name
);
3457 if (startup_info
->original_cwd
&&
3458 !strcmp(startup_info
->original_cwd
, dirs
))
3460 } while (rmdir(dirs
) == 0 && (slash
= strrchr(dirs
, '/')));
3467 * Frees memory within dir which was allocated, and resets fields for further
3468 * use. Does not free dir itself.
3470 void dir_clear(struct dir_struct
*dir
)
3473 struct exclude_list_group
*group
;
3474 struct pattern_list
*pl
;
3475 struct exclude_stack
*stk
;
3476 struct dir_struct
new = DIR_INIT
;
3478 for (i
= EXC_CMDL
; i
<= EXC_FILE
; i
++) {
3479 group
= &dir
->internal
.exclude_list_group
[i
];
3480 for (j
= 0; j
< group
->nr
; j
++) {
3483 free((char *)pl
->src
);
3484 clear_pattern_list(pl
);
3489 for (i
= 0; i
< dir
->ignored_nr
; i
++)
3490 free(dir
->ignored
[i
]);
3491 for (i
= 0; i
< dir
->nr
; i
++)
3492 free(dir
->entries
[i
]);
3496 stk
= dir
->internal
.exclude_stack
;
3498 struct exclude_stack
*prev
= stk
->prev
;
3502 strbuf_release(&dir
->internal
.basebuf
);
3504 memcpy(dir
, &new, sizeof(*dir
));
3507 struct ondisk_untracked_cache
{
3508 struct stat_data info_exclude_stat
;
3509 struct stat_data excludes_file_stat
;
3513 #define ouc_offset(x) offsetof(struct ondisk_untracked_cache, x)
3516 int index
; /* number of written untracked_cache_dir */
3517 struct ewah_bitmap
*check_only
; /* from untracked_cache_dir */
3518 struct ewah_bitmap
*valid
; /* from untracked_cache_dir */
3519 struct ewah_bitmap
*sha1_valid
; /* set if exclude_sha1 is not null */
3521 struct strbuf sb_stat
;
3522 struct strbuf sb_sha1
;
3525 static void stat_data_to_disk(struct stat_data
*to
, const struct stat_data
*from
)
3527 to
->sd_ctime
.sec
= htonl(from
->sd_ctime
.sec
);
3528 to
->sd_ctime
.nsec
= htonl(from
->sd_ctime
.nsec
);
3529 to
->sd_mtime
.sec
= htonl(from
->sd_mtime
.sec
);
3530 to
->sd_mtime
.nsec
= htonl(from
->sd_mtime
.nsec
);
3531 to
->sd_dev
= htonl(from
->sd_dev
);
3532 to
->sd_ino
= htonl(from
->sd_ino
);
3533 to
->sd_uid
= htonl(from
->sd_uid
);
3534 to
->sd_gid
= htonl(from
->sd_gid
);
3535 to
->sd_size
= htonl(from
->sd_size
);
3538 static void write_one_dir(struct untracked_cache_dir
*untracked
,
3539 struct write_data
*wd
)
3541 struct stat_data stat_data
;
3542 struct strbuf
*out
= &wd
->out
;
3543 unsigned char intbuf
[16];
3544 unsigned int intlen
, value
;
3545 int i
= wd
->index
++;
3548 * untracked_nr should be reset whenever valid is clear, but
3551 if (!untracked
->valid
) {
3552 untracked
->untracked_nr
= 0;
3553 untracked
->check_only
= 0;
3556 if (untracked
->check_only
)
3557 ewah_set(wd
->check_only
, i
);
3558 if (untracked
->valid
) {
3559 ewah_set(wd
->valid
, i
);
3560 stat_data_to_disk(&stat_data
, &untracked
->stat_data
);
3561 strbuf_add(&wd
->sb_stat
, &stat_data
, sizeof(stat_data
));
3563 if (!is_null_oid(&untracked
->exclude_oid
)) {
3564 ewah_set(wd
->sha1_valid
, i
);
3565 strbuf_add(&wd
->sb_sha1
, untracked
->exclude_oid
.hash
,
3566 the_hash_algo
->rawsz
);
3569 intlen
= encode_varint(untracked
->untracked_nr
, intbuf
);
3570 strbuf_add(out
, intbuf
, intlen
);
3572 /* skip non-recurse directories */
3573 for (i
= 0, value
= 0; i
< untracked
->dirs_nr
; i
++)
3574 if (untracked
->dirs
[i
]->recurse
)
3576 intlen
= encode_varint(value
, intbuf
);
3577 strbuf_add(out
, intbuf
, intlen
);
3579 strbuf_add(out
, untracked
->name
, strlen(untracked
->name
) + 1);
3581 for (i
= 0; i
< untracked
->untracked_nr
; i
++)
3582 strbuf_add(out
, untracked
->untracked
[i
],
3583 strlen(untracked
->untracked
[i
]) + 1);
3585 for (i
= 0; i
< untracked
->dirs_nr
; i
++)
3586 if (untracked
->dirs
[i
]->recurse
)
3587 write_one_dir(untracked
->dirs
[i
], wd
);
3590 void write_untracked_extension(struct strbuf
*out
, struct untracked_cache
*untracked
)
3592 struct ondisk_untracked_cache
*ouc
;
3593 struct write_data wd
;
3594 unsigned char varbuf
[16];
3596 const unsigned hashsz
= the_hash_algo
->rawsz
;
3598 CALLOC_ARRAY(ouc
, 1);
3599 stat_data_to_disk(&ouc
->info_exclude_stat
, &untracked
->ss_info_exclude
.stat
);
3600 stat_data_to_disk(&ouc
->excludes_file_stat
, &untracked
->ss_excludes_file
.stat
);
3601 ouc
->dir_flags
= htonl(untracked
->dir_flags
);
3603 varint_len
= encode_varint(untracked
->ident
.len
, varbuf
);
3604 strbuf_add(out
, varbuf
, varint_len
);
3605 strbuf_addbuf(out
, &untracked
->ident
);
3607 strbuf_add(out
, ouc
, sizeof(*ouc
));
3608 strbuf_add(out
, untracked
->ss_info_exclude
.oid
.hash
, hashsz
);
3609 strbuf_add(out
, untracked
->ss_excludes_file
.oid
.hash
, hashsz
);
3610 strbuf_add(out
, untracked
->exclude_per_dir
, strlen(untracked
->exclude_per_dir
) + 1);
3613 if (!untracked
->root
) {
3614 varint_len
= encode_varint(0, varbuf
);
3615 strbuf_add(out
, varbuf
, varint_len
);
3620 wd
.check_only
= ewah_new();
3621 wd
.valid
= ewah_new();
3622 wd
.sha1_valid
= ewah_new();
3623 strbuf_init(&wd
.out
, 1024);
3624 strbuf_init(&wd
.sb_stat
, 1024);
3625 strbuf_init(&wd
.sb_sha1
, 1024);
3626 write_one_dir(untracked
->root
, &wd
);
3628 varint_len
= encode_varint(wd
.index
, varbuf
);
3629 strbuf_add(out
, varbuf
, varint_len
);
3630 strbuf_addbuf(out
, &wd
.out
);
3631 ewah_serialize_strbuf(wd
.valid
, out
);
3632 ewah_serialize_strbuf(wd
.check_only
, out
);
3633 ewah_serialize_strbuf(wd
.sha1_valid
, out
);
3634 strbuf_addbuf(out
, &wd
.sb_stat
);
3635 strbuf_addbuf(out
, &wd
.sb_sha1
);
3636 strbuf_addch(out
, '\0'); /* safe guard for string lists */
3638 ewah_free(wd
.valid
);
3639 ewah_free(wd
.check_only
);
3640 ewah_free(wd
.sha1_valid
);
3641 strbuf_release(&wd
.out
);
3642 strbuf_release(&wd
.sb_stat
);
3643 strbuf_release(&wd
.sb_sha1
);
3646 static void free_untracked(struct untracked_cache_dir
*ucd
)
3651 for (i
= 0; i
< ucd
->dirs_nr
; i
++)
3652 free_untracked(ucd
->dirs
[i
]);
3653 for (i
= 0; i
< ucd
->untracked_nr
; i
++)
3654 free(ucd
->untracked
[i
]);
3655 free(ucd
->untracked
);
3660 void free_untracked_cache(struct untracked_cache
*uc
)
3665 free(uc
->exclude_per_dir_to_free
);
3666 strbuf_release(&uc
->ident
);
3667 free_untracked(uc
->root
);
3673 struct untracked_cache_dir
**ucd
;
3674 struct ewah_bitmap
*check_only
;
3675 struct ewah_bitmap
*valid
;
3676 struct ewah_bitmap
*sha1_valid
;
3677 const unsigned char *data
;
3678 const unsigned char *end
;
3681 static void stat_data_from_disk(struct stat_data
*to
, const unsigned char *data
)
3683 memcpy(to
, data
, sizeof(*to
));
3684 to
->sd_ctime
.sec
= ntohl(to
->sd_ctime
.sec
);
3685 to
->sd_ctime
.nsec
= ntohl(to
->sd_ctime
.nsec
);
3686 to
->sd_mtime
.sec
= ntohl(to
->sd_mtime
.sec
);
3687 to
->sd_mtime
.nsec
= ntohl(to
->sd_mtime
.nsec
);
3688 to
->sd_dev
= ntohl(to
->sd_dev
);
3689 to
->sd_ino
= ntohl(to
->sd_ino
);
3690 to
->sd_uid
= ntohl(to
->sd_uid
);
3691 to
->sd_gid
= ntohl(to
->sd_gid
);
3692 to
->sd_size
= ntohl(to
->sd_size
);
3695 static int read_one_dir(struct untracked_cache_dir
**untracked_
,
3696 struct read_data
*rd
)
3698 struct untracked_cache_dir ud
, *untracked
;
3699 const unsigned char *data
= rd
->data
, *end
= rd
->end
;
3700 const unsigned char *eos
;
3704 memset(&ud
, 0, sizeof(ud
));
3706 value
= decode_varint(&data
);
3710 ud
.untracked_alloc
= value
;
3711 ud
.untracked_nr
= value
;
3712 if (ud
.untracked_nr
)
3713 ALLOC_ARRAY(ud
.untracked
, ud
.untracked_nr
);
3715 ud
.dirs_alloc
= ud
.dirs_nr
= decode_varint(&data
);
3718 ALLOC_ARRAY(ud
.dirs
, ud
.dirs_nr
);
3720 eos
= memchr(data
, '\0', end
- data
);
3721 if (!eos
|| eos
== end
)
3724 *untracked_
= untracked
= xmalloc(st_add3(sizeof(*untracked
), eos
- data
, 1));
3725 memcpy(untracked
, &ud
, sizeof(ud
));
3726 memcpy(untracked
->name
, data
, eos
- data
+ 1);
3729 for (i
= 0; i
< untracked
->untracked_nr
; i
++) {
3730 eos
= memchr(data
, '\0', end
- data
);
3731 if (!eos
|| eos
== end
)
3733 untracked
->untracked
[i
] = xmemdupz(data
, eos
- data
);
3737 rd
->ucd
[rd
->index
++] = untracked
;
3740 for (i
= 0; i
< untracked
->dirs_nr
; i
++) {
3741 if (read_one_dir(untracked
->dirs
+ i
, rd
) < 0)
3747 static void set_check_only(size_t pos
, void *cb
)
3749 struct read_data
*rd
= cb
;
3750 struct untracked_cache_dir
*ud
= rd
->ucd
[pos
];
3754 static void read_stat(size_t pos
, void *cb
)
3756 struct read_data
*rd
= cb
;
3757 struct untracked_cache_dir
*ud
= rd
->ucd
[pos
];
3758 if (rd
->data
+ sizeof(struct stat_data
) > rd
->end
) {
3759 rd
->data
= rd
->end
+ 1;
3762 stat_data_from_disk(&ud
->stat_data
, rd
->data
);
3763 rd
->data
+= sizeof(struct stat_data
);
3767 static void read_oid(size_t pos
, void *cb
)
3769 struct read_data
*rd
= cb
;
3770 struct untracked_cache_dir
*ud
= rd
->ucd
[pos
];
3771 if (rd
->data
+ the_hash_algo
->rawsz
> rd
->end
) {
3772 rd
->data
= rd
->end
+ 1;
3775 oidread(&ud
->exclude_oid
, rd
->data
);
3776 rd
->data
+= the_hash_algo
->rawsz
;
3779 static void load_oid_stat(struct oid_stat
*oid_stat
, const unsigned char *data
,
3780 const unsigned char *sha1
)
3782 stat_data_from_disk(&oid_stat
->stat
, data
);
3783 oidread(&oid_stat
->oid
, sha1
);
3784 oid_stat
->valid
= 1;
3787 struct untracked_cache
*read_untracked_extension(const void *data
, unsigned long sz
)
3789 struct untracked_cache
*uc
;
3790 struct read_data rd
;
3791 const unsigned char *next
= data
, *end
= (const unsigned char *)data
+ sz
;
3795 const char *exclude_per_dir
;
3796 const unsigned hashsz
= the_hash_algo
->rawsz
;
3797 const unsigned offset
= sizeof(struct ondisk_untracked_cache
);
3798 const unsigned exclude_per_dir_offset
= offset
+ 2 * hashsz
;
3800 if (sz
<= 1 || end
[-1] != '\0')
3804 ident_len
= decode_varint(&next
);
3805 if (next
+ ident_len
> end
)
3807 ident
= (const char *)next
;
3810 if (next
+ exclude_per_dir_offset
+ 1 > end
)
3813 CALLOC_ARRAY(uc
, 1);
3814 strbuf_init(&uc
->ident
, ident_len
);
3815 strbuf_add(&uc
->ident
, ident
, ident_len
);
3816 load_oid_stat(&uc
->ss_info_exclude
,
3817 next
+ ouc_offset(info_exclude_stat
),
3819 load_oid_stat(&uc
->ss_excludes_file
,
3820 next
+ ouc_offset(excludes_file_stat
),
3821 next
+ offset
+ hashsz
);
3822 uc
->dir_flags
= get_be32(next
+ ouc_offset(dir_flags
));
3823 exclude_per_dir
= (const char *)next
+ exclude_per_dir_offset
;
3824 uc
->exclude_per_dir
= uc
->exclude_per_dir_to_free
= xstrdup(exclude_per_dir
);
3825 /* NUL after exclude_per_dir is covered by sizeof(*ouc) */
3826 next
+= exclude_per_dir_offset
+ strlen(exclude_per_dir
) + 1;
3830 len
= decode_varint(&next
);
3831 if (next
> end
|| len
== 0)
3834 rd
.valid
= ewah_new();
3835 rd
.check_only
= ewah_new();
3836 rd
.sha1_valid
= ewah_new();
3840 ALLOC_ARRAY(rd
.ucd
, len
);
3842 if (read_one_dir(&uc
->root
, &rd
) || rd
.index
!= len
)
3846 len
= ewah_read_mmap(rd
.valid
, next
, end
- next
);
3851 len
= ewah_read_mmap(rd
.check_only
, next
, end
- next
);
3856 len
= ewah_read_mmap(rd
.sha1_valid
, next
, end
- next
);
3860 ewah_each_bit(rd
.check_only
, set_check_only
, &rd
);
3861 rd
.data
= next
+ len
;
3862 ewah_each_bit(rd
.valid
, read_stat
, &rd
);
3863 ewah_each_bit(rd
.sha1_valid
, read_oid
, &rd
);
3868 ewah_free(rd
.valid
);
3869 ewah_free(rd
.check_only
);
3870 ewah_free(rd
.sha1_valid
);
3873 free_untracked_cache(uc
);
3879 static void invalidate_one_directory(struct untracked_cache
*uc
,
3880 struct untracked_cache_dir
*ucd
)
3882 uc
->dir_invalidated
++;
3884 ucd
->untracked_nr
= 0;
3888 * Normally when an entry is added or removed from a directory,
3889 * invalidating that directory is enough. No need to touch its
3890 * ancestors. When a directory is shown as "foo/bar/" in git-status
3891 * however, deleting or adding an entry may have cascading effect.
3893 * Say the "foo/bar/file" has become untracked, we need to tell the
3894 * untracked_cache_dir of "foo" that "bar/" is not an untracked
3895 * directory any more (because "bar" is managed by foo as an untracked
3898 * Similarly, if "foo/bar/file" moves from untracked to tracked and it
3899 * was the last untracked entry in the entire "foo", we should show
3900 * "foo/" instead. Which means we have to invalidate past "bar" up to
3903 * This function traverses all directories from root to leaf. If there
3904 * is a chance of one of the above cases happening, we invalidate back
3905 * to root. Otherwise we just invalidate the leaf. There may be a more
3906 * sophisticated way than checking for SHOW_OTHER_DIRECTORIES to
3907 * detect these cases and avoid unnecessary invalidation, for example,
3908 * checking for the untracked entry named "bar/" in "foo", but for now
3909 * stick to something safe and simple.
3911 static int invalidate_one_component(struct untracked_cache
*uc
,
3912 struct untracked_cache_dir
*dir
,
3913 const char *path
, int len
)
3915 const char *rest
= strchr(path
, '/');
3918 int component_len
= rest
- path
;
3919 struct untracked_cache_dir
*d
=
3920 lookup_untracked(uc
, dir
, path
, component_len
);
3922 invalidate_one_component(uc
, d
, rest
+ 1,
3923 len
- (component_len
+ 1));
3925 invalidate_one_directory(uc
, dir
);
3929 invalidate_one_directory(uc
, dir
);
3930 return uc
->dir_flags
& DIR_SHOW_OTHER_DIRECTORIES
;
3933 void untracked_cache_invalidate_path(struct index_state
*istate
,
3934 const char *path
, int safe_path
)
3936 if (!istate
->untracked
|| !istate
->untracked
->root
)
3938 if (!safe_path
&& !verify_path(path
, 0))
3940 invalidate_one_component(istate
->untracked
, istate
->untracked
->root
,
3941 path
, strlen(path
));
3944 void untracked_cache_invalidate_trimmed_path(struct index_state
*istate
,
3948 size_t len
= strlen(path
);
3951 BUG("untracked_cache_invalidate_trimmed_path given zero length path");
3953 if (path
[len
- 1] != '/') {
3954 untracked_cache_invalidate_path(istate
, path
, safe_path
);
3956 struct strbuf tmp
= STRBUF_INIT
;
3958 strbuf_add(&tmp
, path
, len
- 1);
3959 untracked_cache_invalidate_path(istate
, tmp
.buf
, safe_path
);
3960 strbuf_release(&tmp
);
3964 void untracked_cache_remove_from_index(struct index_state
*istate
,
3967 untracked_cache_invalidate_path(istate
, path
, 1);
3970 void untracked_cache_add_to_index(struct index_state
*istate
,
3973 untracked_cache_invalidate_path(istate
, path
, 1);
3976 static void connect_wt_gitdir_in_nested(const char *sub_worktree
,
3977 const char *sub_gitdir
)
3980 struct repository subrepo
;
3981 struct strbuf sub_wt
= STRBUF_INIT
;
3982 struct strbuf sub_gd
= STRBUF_INIT
;
3984 const struct submodule
*sub
;
3986 /* If the submodule has no working tree, we can ignore it. */
3987 if (repo_init(&subrepo
, sub_gitdir
, sub_worktree
))
3990 if (repo_read_index(&subrepo
) < 0)
3991 die(_("index file corrupt in repo %s"), subrepo
.gitdir
);
3993 /* TODO: audit for interaction with sparse-index. */
3994 ensure_full_index(subrepo
.index
);
3995 for (i
= 0; i
< subrepo
.index
->cache_nr
; i
++) {
3996 const struct cache_entry
*ce
= subrepo
.index
->cache
[i
];
3998 if (!S_ISGITLINK(ce
->ce_mode
))
4001 while (i
+ 1 < subrepo
.index
->cache_nr
&&
4002 !strcmp(ce
->name
, subrepo
.index
->cache
[i
+ 1]->name
))
4004 * Skip entries with the same name in different stages
4005 * to make sure an entry is returned only once.
4009 sub
= submodule_from_path(&subrepo
, null_oid(), ce
->name
);
4010 if (!sub
|| !is_submodule_active(&subrepo
, ce
->name
))
4011 /* .gitmodules broken or inactive sub */
4014 strbuf_reset(&sub_wt
);
4015 strbuf_reset(&sub_gd
);
4016 strbuf_addf(&sub_wt
, "%s/%s", sub_worktree
, sub
->path
);
4017 submodule_name_to_gitdir(&sub_gd
, &subrepo
, sub
->name
);
4019 connect_work_tree_and_git_dir(sub_wt
.buf
, sub_gd
.buf
, 1);
4021 strbuf_release(&sub_wt
);
4022 strbuf_release(&sub_gd
);
4023 repo_clear(&subrepo
);
4026 void connect_work_tree_and_git_dir(const char *work_tree_
,
4027 const char *git_dir_
,
4028 int recurse_into_nested
)
4030 struct strbuf gitfile_sb
= STRBUF_INIT
;
4031 struct strbuf cfg_sb
= STRBUF_INIT
;
4032 struct strbuf rel_path
= STRBUF_INIT
;
4033 char *git_dir
, *work_tree
;
4035 /* Prepare .git file */
4036 strbuf_addf(&gitfile_sb
, "%s/.git", work_tree_
);
4037 if (safe_create_leading_directories_const(gitfile_sb
.buf
))
4038 die(_("could not create directories for %s"), gitfile_sb
.buf
);
4040 /* Prepare config file */
4041 strbuf_addf(&cfg_sb
, "%s/config", git_dir_
);
4042 if (safe_create_leading_directories_const(cfg_sb
.buf
))
4043 die(_("could not create directories for %s"), cfg_sb
.buf
);
4045 git_dir
= real_pathdup(git_dir_
, 1);
4046 work_tree
= real_pathdup(work_tree_
, 1);
4048 /* Write .git file */
4049 write_file(gitfile_sb
.buf
, "gitdir: %s",
4050 relative_path(git_dir
, work_tree
, &rel_path
));
4051 /* Update core.worktree setting */
4052 git_config_set_in_file(cfg_sb
.buf
, "core.worktree",
4053 relative_path(work_tree
, git_dir
, &rel_path
));
4055 strbuf_release(&gitfile_sb
);
4056 strbuf_release(&cfg_sb
);
4057 strbuf_release(&rel_path
);
4059 if (recurse_into_nested
)
4060 connect_wt_gitdir_in_nested(work_tree
, git_dir
);
4067 * Migrate the git directory of the given path from old_git_dir to new_git_dir.
4069 void relocate_gitdir(const char *path
, const char *old_git_dir
, const char *new_git_dir
)
4071 if (rename(old_git_dir
, new_git_dir
) < 0)
4072 die_errno(_("could not migrate git directory from '%s' to '%s'"),
4073 old_git_dir
, new_git_dir
);
4075 connect_work_tree_and_git_dir(path
, new_git_dir
, 0);
4078 int path_match_flags(const char *const str
, const enum path_match_flags flags
)
4080 const char *p
= str
;
4082 if (flags
& PATH_MATCH_NATIVE
&&
4083 flags
& PATH_MATCH_XPLATFORM
)
4084 BUG("path_match_flags() must get one match kind, not multiple!");
4085 else if (!(flags
& PATH_MATCH_KINDS_MASK
))
4086 BUG("path_match_flags() must get at least one match kind!");
4088 if (flags
& PATH_MATCH_STARTS_WITH_DOT_SLASH
&&
4089 flags
& PATH_MATCH_STARTS_WITH_DOT_DOT_SLASH
)
4090 BUG("path_match_flags() must get one platform kind, not multiple!");
4091 else if (!(flags
& PATH_MATCH_PLATFORM_MASK
))
4092 BUG("path_match_flags() must get at least one platform kind!");
4096 if (flags
& PATH_MATCH_STARTS_WITH_DOT_DOT_SLASH
&&
4100 if (flags
& PATH_MATCH_NATIVE
)
4101 return is_dir_sep(*p
);
4102 else if (flags
& PATH_MATCH_XPLATFORM
)
4103 return is_xplatform_dir_sep(*p
);