diff options
Diffstat (limited to 'dir.c')
| -rw-r--r-- | dir.c | 842 |
1 files changed, 618 insertions, 224 deletions
@@ -2,8 +2,6 @@ * This handles recursive filename detection with exclude * files, index knowledge etc.. * - * See Documentation/technical/api-directory-listing.txt - * * Copyright (C) Linus Torvalds, 2005-2006 * Junio Hamano, 2005-2006 */ @@ -43,7 +41,8 @@ struct cached_dir { int nr_files; int nr_dirs; - struct dirent *de; + const char *d_name; + int d_type; const char *file; struct untracked_cache_dir *ucd; }; @@ -52,8 +51,8 @@ static enum path_treatment read_directory_recursive(struct dir_struct *dir, struct index_state *istate, const char *path, int len, struct untracked_cache_dir *untracked, int check_only, int stop_at_first_file, const struct pathspec *pathspec); -static int get_dtype(struct dirent *de, struct index_state *istate, - const char *path, int len); +static int resolve_dtype(int dtype, struct index_state *istate, + const char *path, int len); int count_slashes(const char *s) { @@ -139,7 +138,7 @@ static size_t common_prefix_len(const struct pathspec *pathspec) * ":(icase)path" is treated as a pathspec full of * wildcard. In other words, only prefix is considered common * prefix. If the pathspec is abc/foo abc/bar, running in - * subdir xyz, the common prefix is still xyz, not xuz/abc as + * subdir xyz, the common prefix is still xyz, not xyz/abc as * in non-:(icase). */ GUARD_PATHSPEC(pathspec, @@ -273,19 +272,30 @@ static int do_read_blob(const struct object_id *oid, struct oid_stat *oid_stat, #define DO_MATCH_EXCLUDE (1<<0) #define DO_MATCH_DIRECTORY (1<<1) -#define DO_MATCH_SUBMODULE (1<<2) +#define DO_MATCH_LEADING_PATHSPEC (1<<2) /* - * Does 'match' match the given name? - * A match is found if + * Does the given pathspec match the given name? A match is found if + * + * (1) the pathspec string is leading directory of 'name' ("RECURSIVELY"), or + * (2) the pathspec string has a leading part matching 'name' ("LEADING"), or + * (3) the pathspec string is a wildcard and matches 'name' ("WILDCARD"), or + * (4) the pathspec string is exactly the same as 'name' ("EXACT"). * - * (1) the 'match' string is leading directory of 'name', or - * (2) the 'match' string is a wildcard and matches 'name', or - * (3) the 'match' string is exactly the same as 'name'. + * Return value tells which case it was (1-4), or 0 when there is no match. * - * and the return value tells which case it was. + * It may be instructive to look at a small table of concrete examples + * to understand the differences between 1, 2, and 4: * - * It returns 0 when there is no match. + * Pathspecs + * | a/b | a/b/ | a/b/c + * ------+-----------+-----------+------------ + * a/b | EXACT | EXACT[1] | LEADING[2] + * Names a/b/ | RECURSIVE | EXACT | LEADING[2] + * a/b/c | RECURSIVE | RECURSIVE | EXACT + * + * [1] Only if DO_MATCH_DIRECTORY is passed; otherwise, this is NOT a match. + * [2] Only if DO_MATCH_LEADING_PATHSPEC is passed; otherwise, not a match. */ static int match_pathspec_item(const struct index_state *istate, const struct pathspec_item *item, int prefix, @@ -353,21 +363,29 @@ static int match_pathspec_item(const struct index_state *istate, item->nowildcard_len - prefix)) return MATCHED_FNMATCH; - /* Perform checks to see if "name" is a super set of the pathspec */ - if (flags & DO_MATCH_SUBMODULE) { + /* Perform checks to see if "name" is a leading string of the pathspec */ + if (flags & DO_MATCH_LEADING_PATHSPEC) { /* name is a literal prefix of the pathspec */ + int offset = name[namelen-1] == '/' ? 1 : 0; if ((namelen < matchlen) && - (match[namelen] == '/') && + (match[namelen-offset] == '/') && !ps_strncmp(item, match, name, namelen)) - return MATCHED_RECURSIVELY; + return MATCHED_RECURSIVELY_LEADING_PATHSPEC; - /* name" doesn't match up to the first wild character */ + /* name doesn't match up to the first wild character */ if (item->nowildcard_len < item->len && ps_strncmp(item, match, name, item->nowildcard_len - prefix)) return 0; /* + * name has no wildcard, and it didn't match as a leading + * pathspec so return. + */ + if (item->nowildcard_len == item->len) + return 0; + + /* * Here is where we would perform a wildmatch to check if * "name" can be matched as a directory (or a prefix) against * the pathspec. Since wildmatch doesn't have this capability @@ -376,7 +394,7 @@ static int match_pathspec_item(const struct index_state *istate, * The submodules themselves will be able to perform more * accurate matching to determine if the pathspec matches. */ - return MATCHED_RECURSIVELY; + return MATCHED_RECURSIVELY_LEADING_PATHSPEC; } return 0; @@ -497,7 +515,7 @@ int submodule_path_match(const struct index_state *istate, strlen(submodule_name), 0, seen, DO_MATCH_DIRECTORY | - DO_MATCH_SUBMODULE); + DO_MATCH_LEADING_PATHSPEC); return matched; } @@ -561,7 +579,7 @@ int no_wildcard(const char *string) return string[simple_length(string)] == '\0'; } -void parse_exclude_pattern(const char **pattern, +void parse_path_pattern(const char **pattern, int *patternlen, unsigned *flags, int *nowildcardlen) @@ -571,20 +589,20 @@ void parse_exclude_pattern(const char **pattern, *flags = 0; if (*p == '!') { - *flags |= EXC_FLAG_NEGATIVE; + *flags |= PATTERN_FLAG_NEGATIVE; p++; } len = strlen(p); if (len && p[len - 1] == '/') { len--; - *flags |= EXC_FLAG_MUSTBEDIR; + *flags |= PATTERN_FLAG_MUSTBEDIR; } for (i = 0; i < len; i++) { if (p[i] == '/') break; } if (i == len) - *flags |= EXC_FLAG_NODIR; + *flags |= PATTERN_FLAG_NODIR; *nowildcardlen = simple_length(p); /* * we should have excluded the trailing slash from 'p' too, @@ -594,35 +612,261 @@ void parse_exclude_pattern(const char **pattern, if (*nowildcardlen > len) *nowildcardlen = len; if (*p == '*' && no_wildcard(p + 1)) - *flags |= EXC_FLAG_ENDSWITH; + *flags |= PATTERN_FLAG_ENDSWITH; *pattern = p; *patternlen = len; } -void add_exclude(const char *string, const char *base, - int baselen, struct exclude_list *el, int srcpos) +int pl_hashmap_cmp(const void *unused_cmp_data, + const struct hashmap_entry *a, + const struct hashmap_entry *b, + const void *key) { - struct exclude *x; + const struct pattern_entry *ee1 = + container_of(a, struct pattern_entry, ent); + const struct pattern_entry *ee2 = + container_of(b, struct pattern_entry, ent); + + size_t min_len = ee1->patternlen <= ee2->patternlen + ? ee1->patternlen + : ee2->patternlen; + + if (ignore_case) + return strncasecmp(ee1->pattern, ee2->pattern, min_len); + return strncmp(ee1->pattern, ee2->pattern, min_len); +} + +static char *dup_and_filter_pattern(const char *pattern) +{ + char *set, *read; + size_t count = 0; + char *result = xstrdup(pattern); + + set = result; + read = result; + + while (*read) { + /* skip escape characters (once) */ + if (*read == '\\') + read++; + + *set = *read; + + set++; + read++; + count++; + } + *set = 0; + + if (count > 2 && + *(set - 1) == '*' && + *(set - 2) == '/') + *(set - 2) = 0; + + return result; +} + +static void add_pattern_to_hashsets(struct pattern_list *pl, struct path_pattern *given) +{ + struct pattern_entry *translated; + char *truncated; + char *data = NULL; + const char *prev, *cur, *next; + + if (!pl->use_cone_patterns) + return; + + if (given->flags & PATTERN_FLAG_NEGATIVE && + given->flags & PATTERN_FLAG_MUSTBEDIR && + !strcmp(given->pattern, "/*")) { + pl->full_cone = 0; + return; + } + + if (!given->flags && !strcmp(given->pattern, "/*")) { + pl->full_cone = 1; + return; + } + + if (given->patternlen < 2 || + *given->pattern == '*' || + strstr(given->pattern, "**")) { + /* Not a cone pattern. */ + warning(_("unrecognized pattern: '%s'"), given->pattern); + goto clear_hashmaps; + } + + prev = given->pattern; + cur = given->pattern + 1; + next = given->pattern + 2; + + while (*cur) { + /* Watch for glob characters '*', '\', '[', '?' */ + if (!is_glob_special(*cur)) + goto increment; + + /* But only if *prev != '\\' */ + if (*prev == '\\') + goto increment; + + /* But allow the initial '\' */ + if (*cur == '\\' && + is_glob_special(*next)) + goto increment; + + /* But a trailing '/' then '*' is fine */ + if (*prev == '/' && + *cur == '*' && + *next == 0) + goto increment; + + /* Not a cone pattern. */ + warning(_("unrecognized pattern: '%s'"), given->pattern); + goto clear_hashmaps; + + increment: + prev++; + cur++; + next++; + } + + if (given->patternlen > 2 && + !strcmp(given->pattern + given->patternlen - 2, "/*")) { + if (!(given->flags & PATTERN_FLAG_NEGATIVE)) { + /* Not a cone pattern. */ + warning(_("unrecognized pattern: '%s'"), given->pattern); + goto clear_hashmaps; + } + + truncated = dup_and_filter_pattern(given->pattern); + + translated = xmalloc(sizeof(struct pattern_entry)); + translated->pattern = truncated; + translated->patternlen = given->patternlen - 2; + hashmap_entry_init(&translated->ent, + ignore_case ? + strihash(translated->pattern) : + strhash(translated->pattern)); + + if (!hashmap_get_entry(&pl->recursive_hashmap, + translated, ent, NULL)) { + /* We did not see the "parent" included */ + warning(_("unrecognized negative pattern: '%s'"), + given->pattern); + free(truncated); + free(translated); + goto clear_hashmaps; + } + + hashmap_add(&pl->parent_hashmap, &translated->ent); + hashmap_remove(&pl->recursive_hashmap, &translated->ent, &data); + free(data); + return; + } + + if (given->flags & PATTERN_FLAG_NEGATIVE) { + warning(_("unrecognized negative pattern: '%s'"), + given->pattern); + goto clear_hashmaps; + } + + translated = xmalloc(sizeof(struct pattern_entry)); + + translated->pattern = dup_and_filter_pattern(given->pattern); + translated->patternlen = given->patternlen; + hashmap_entry_init(&translated->ent, + ignore_case ? + strihash(translated->pattern) : + strhash(translated->pattern)); + + hashmap_add(&pl->recursive_hashmap, &translated->ent); + + if (hashmap_get_entry(&pl->parent_hashmap, translated, ent, NULL)) { + /* we already included this at the parent level */ + warning(_("your sparse-checkout file may have issues: pattern '%s' is repeated"), + given->pattern); + hashmap_remove(&pl->parent_hashmap, &translated->ent, &data); + free(data); + free(translated); + } + + return; + +clear_hashmaps: + warning(_("disabling cone pattern matching")); + hashmap_free_entries(&pl->parent_hashmap, struct pattern_entry, ent); + hashmap_free_entries(&pl->recursive_hashmap, struct pattern_entry, ent); + pl->use_cone_patterns = 0; +} + +static int hashmap_contains_path(struct hashmap *map, + struct strbuf *pattern) +{ + struct pattern_entry p; + + /* Check straight mapping */ + p.pattern = pattern->buf; + p.patternlen = pattern->len; + hashmap_entry_init(&p.ent, + ignore_case ? + strihash(p.pattern) : + strhash(p.pattern)); + return !!hashmap_get_entry(map, &p, ent, NULL); +} + +int hashmap_contains_parent(struct hashmap *map, + const char *path, + struct strbuf *buffer) +{ + char *slash_pos; + + strbuf_setlen(buffer, 0); + + if (path[0] != '/') + strbuf_addch(buffer, '/'); + + strbuf_addstr(buffer, path); + + slash_pos = strrchr(buffer->buf, '/'); + + while (slash_pos > buffer->buf) { + strbuf_setlen(buffer, slash_pos - buffer->buf); + + if (hashmap_contains_path(map, buffer)) + return 1; + + slash_pos = strrchr(buffer->buf, '/'); + } + + return 0; +} + +void add_pattern(const char *string, const char *base, + int baselen, struct pattern_list *pl, int srcpos) +{ + struct path_pattern *pattern; int patternlen; unsigned flags; int nowildcardlen; - parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); - if (flags & EXC_FLAG_MUSTBEDIR) { - FLEXPTR_ALLOC_MEM(x, pattern, string, patternlen); + parse_path_pattern(&string, &patternlen, &flags, &nowildcardlen); + if (flags & PATTERN_FLAG_MUSTBEDIR) { + FLEXPTR_ALLOC_MEM(pattern, pattern, string, patternlen); } else { - x = xmalloc(sizeof(*x)); - x->pattern = string; + pattern = xmalloc(sizeof(*pattern)); + pattern->pattern = string; } - x->patternlen = patternlen; - x->nowildcardlen = nowildcardlen; - x->base = base; - x->baselen = baselen; - x->flags = flags; - x->srcpos = srcpos; - ALLOC_GROW(el->excludes, el->nr + 1, el->alloc); - el->excludes[el->nr++] = x; - x->el = el; + pattern->patternlen = patternlen; + pattern->nowildcardlen = nowildcardlen; + pattern->base = base; + pattern->baselen = baselen; + pattern->flags = flags; + pattern->srcpos = srcpos; + ALLOC_GROW(pl->patterns, pl->nr + 1, pl->alloc); + pl->patterns[pl->nr++] = pattern; + pattern->pl = pl; + + add_pattern_to_hashsets(pl, pattern); } static int read_skip_worktree_file_from_index(const struct index_state *istate, @@ -643,19 +887,19 @@ static int read_skip_worktree_file_from_index(const struct index_state *istate, } /* - * Frees memory within el which was allocated for exclude patterns and - * the file buffer. Does not free el itself. + * Frees memory within pl which was allocated for exclude patterns and + * the file buffer. Does not free pl itself. */ -void clear_exclude_list(struct exclude_list *el) +void clear_pattern_list(struct pattern_list *pl) { int i; - for (i = 0; i < el->nr; i++) - free(el->excludes[i]); - free(el->excludes); - free(el->filebuf); + for (i = 0; i < pl->nr; i++) + free(pl->patterns[i]); + free(pl->patterns); + free(pl->filebuf); - memset(el, 0, sizeof(*el)); + memset(pl, 0, sizeof(*pl)); } static void trim_trailing_spaces(char *buf) @@ -762,21 +1006,21 @@ static void invalidate_directory(struct untracked_cache *uc, dir->dirs[i]->recurse = 0; } -static int add_excludes_from_buffer(char *buf, size_t size, +static int add_patterns_from_buffer(char *buf, size_t size, const char *base, int baselen, - struct exclude_list *el); + struct pattern_list *pl); /* * Given a file with name "fname", read it (either from disk, or from * an index if 'istate' is non-null), parse it and store the - * exclude rules in "el". + * exclude rules in "pl". * * If "ss" is not NULL, compute SHA-1 of the exclude file and fill - * stat data from disk (only valid if add_excludes returns zero). If + * stat data from disk (only valid if add_patterns returns zero). If * ss_valid is non-zero, "ss" must contain good value as input. */ -static int add_excludes(const char *fname, const char *base, int baselen, - struct exclude_list *el, struct index_state *istate, +static int add_patterns(const char *fname, const char *base, int baselen, + struct pattern_list *pl, struct index_state *istate, struct oid_stat *oid_stat) { struct stat st; @@ -830,28 +1074,31 @@ static int add_excludes(const char *fname, const char *base, int baselen, oidcpy(&oid_stat->oid, &istate->cache[pos]->oid); else - hash_object_file(buf, size, "blob", - &oid_stat->oid); + hash_object_file(the_hash_algo, buf, size, + "blob", &oid_stat->oid); fill_stat_data(&oid_stat->stat, &st); oid_stat->valid = 1; } } - add_excludes_from_buffer(buf, size, base, baselen, el); + add_patterns_from_buffer(buf, size, base, baselen, pl); return 0; } -static int add_excludes_from_buffer(char *buf, size_t size, +static int add_patterns_from_buffer(char *buf, size_t size, const char *base, int baselen, - struct exclude_list *el) + struct pattern_list *pl) { int i, lineno = 1; char *entry; - el->filebuf = buf; + hashmap_init(&pl->recursive_hashmap, pl_hashmap_cmp, NULL, 0); + hashmap_init(&pl->parent_hashmap, pl_hashmap_cmp, NULL, 0); + + pl->filebuf = buf; if (skip_utf8_bom(&buf, size)) - size -= buf - el->filebuf; + size -= buf - pl->filebuf; entry = buf; @@ -860,7 +1107,7 @@ static int add_excludes_from_buffer(char *buf, size_t size, if (entry != buf + i && entry[0] != '#') { buf[i - (i && buf[i-1] == '\r')] = 0; trim_trailing_spaces(entry); - add_exclude(entry, base, baselen, el, lineno); + add_pattern(entry, base, baselen, pl, lineno); } lineno++; entry = buf + i + 1; @@ -869,17 +1116,17 @@ static int add_excludes_from_buffer(char *buf, size_t size, return 0; } -int add_excludes_from_file_to_list(const char *fname, const char *base, - int baselen, struct exclude_list *el, +int add_patterns_from_file_to_list(const char *fname, const char *base, + int baselen, struct pattern_list *pl, struct index_state *istate) { - return add_excludes(fname, base, baselen, el, istate, NULL); + return add_patterns(fname, base, baselen, pl, istate, NULL); } -int add_excludes_from_blob_to_list( +int add_patterns_from_blob_to_list( struct object_id *oid, const char *base, int baselen, - struct exclude_list *el) + struct pattern_list *pl) { char *buf; size_t size; @@ -889,31 +1136,31 @@ int add_excludes_from_blob_to_list( if (r != 1) return r; - add_excludes_from_buffer(buf, size, base, baselen, el); + add_patterns_from_buffer(buf, size, base, baselen, pl); return 0; } -struct exclude_list *add_exclude_list(struct dir_struct *dir, +struct pattern_list *add_pattern_list(struct dir_struct *dir, int group_type, const char *src) { - struct exclude_list *el; + struct pattern_list *pl; struct exclude_list_group *group; group = &dir->exclude_list_group[group_type]; - ALLOC_GROW(group->el, group->nr + 1, group->alloc); - el = &group->el[group->nr++]; - memset(el, 0, sizeof(*el)); - el->src = src; - return el; + ALLOC_GROW(group->pl, group->nr + 1, group->alloc); + pl = &group->pl[group->nr++]; + memset(pl, 0, sizeof(*pl)); + pl->src = src; + return pl; } /* * Used to set up core.excludesfile and .git/info/exclude lists. */ -static void add_excludes_from_file_1(struct dir_struct *dir, const char *fname, +static void add_patterns_from_file_1(struct dir_struct *dir, const char *fname, struct oid_stat *oid_stat) { - struct exclude_list *el; + struct pattern_list *pl; /* * catch setup_standard_excludes() that's called before * dir->untracked is assigned. That function behaves @@ -921,15 +1168,15 @@ static void add_excludes_from_file_1(struct dir_struct *dir, const char *fname, */ if (!dir->untracked) dir->unmanaged_exclude_files++; - el = add_exclude_list(dir, EXC_FILE, fname); - if (add_excludes(fname, "", 0, el, NULL, oid_stat) < 0) + pl = add_pattern_list(dir, EXC_FILE, fname); + if (add_patterns(fname, "", 0, pl, NULL, oid_stat) < 0) die(_("cannot use %s as an exclude file"), fname); } -void add_excludes_from_file(struct dir_struct *dir, const char *fname) +void add_patterns_from_file(struct dir_struct *dir, const char *fname) { dir->unmanaged_exclude_files++; /* see validate_untracked_cache() */ - add_excludes_from_file_1(dir, fname, NULL); + add_patterns_from_file_1(dir, fname, NULL); } int match_basename(const char *basename, int basenamelen, @@ -940,7 +1187,7 @@ int match_basename(const char *basename, int basenamelen, if (patternlen == basenamelen && !fspathncmp(pattern, basename, basenamelen)) return 1; - } else if (flags & EXC_FLAG_ENDSWITH) { + } else if (flags & PATTERN_FLAG_ENDSWITH) { /* "*literal" matching against "fooliteral" */ if (patternlen - 1 <= basenamelen && !fspathncmp(pattern + 1, @@ -1021,85 +1268,138 @@ int match_pathname(const char *pathname, int pathlen, * any, determines the fate. Returns the exclude_list element which * matched, or NULL for undecided. */ -static struct exclude *last_exclude_matching_from_list(const char *pathname, +static struct path_pattern *last_matching_pattern_from_list(const char *pathname, int pathlen, const char *basename, int *dtype, - struct exclude_list *el, + struct pattern_list *pl, struct index_state *istate) { - struct exclude *exc = NULL; /* undecided */ + struct path_pattern *res = NULL; /* undecided */ int i; - if (!el->nr) + if (!pl->nr) return NULL; /* undefined */ - for (i = el->nr - 1; 0 <= i; i--) { - struct exclude *x = el->excludes[i]; - const char *exclude = x->pattern; - int prefix = x->nowildcardlen; + for (i = pl->nr - 1; 0 <= i; i--) { + struct path_pattern *pattern = pl->patterns[i]; + const char *exclude = pattern->pattern; + int prefix = pattern->nowildcardlen; - if (x->flags & EXC_FLAG_MUSTBEDIR) { - if (*dtype == DT_UNKNOWN) - *dtype = get_dtype(NULL, istate, pathname, pathlen); + if (pattern->flags & PATTERN_FLAG_MUSTBEDIR) { + *dtype = resolve_dtype(*dtype, istate, pathname, pathlen); if (*dtype != DT_DIR) continue; } - if (x->flags & EXC_FLAG_NODIR) { + if (pattern->flags & PATTERN_FLAG_NODIR) { if (match_basename(basename, pathlen - (basename - pathname), - exclude, prefix, x->patternlen, - x->flags)) { - exc = x; + exclude, prefix, pattern->patternlen, + pattern->flags)) { + res = pattern; break; } continue; } - assert(x->baselen == 0 || x->base[x->baselen - 1] == '/'); + assert(pattern->baselen == 0 || + pattern->base[pattern->baselen - 1] == '/'); if (match_pathname(pathname, pathlen, - x->base, x->baselen ? x->baselen - 1 : 0, - exclude, prefix, x->patternlen, x->flags)) { - exc = x; + pattern->base, + pattern->baselen ? pattern->baselen - 1 : 0, + exclude, prefix, pattern->patternlen, + pattern->flags)) { + res = pattern; break; } } - return exc; + return res; } /* - * Scan the list and let the last match determine the fate. - * Return 1 for exclude, 0 for include and -1 for undecided. + * Scan the list of patterns to determine if the ordered list + * of patterns matches on 'pathname'. + * + * Return 1 for a match, 0 for not matched and -1 for undecided. */ -int is_excluded_from_list(const char *pathname, - int pathlen, const char *basename, int *dtype, - struct exclude_list *el, struct index_state *istate) -{ - struct exclude *exclude; - exclude = last_exclude_matching_from_list(pathname, pathlen, basename, - dtype, el, istate); - if (exclude) - return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1; - return -1; /* undecided */ +enum pattern_match_result path_matches_pattern_list( + const char *pathname, int pathlen, + const char *basename, int *dtype, + struct pattern_list *pl, + struct index_state *istate) +{ + struct path_pattern *pattern; + struct strbuf parent_pathname = STRBUF_INIT; + int result = NOT_MATCHED; + const char *slash_pos; + + if (!pl->use_cone_patterns) { + pattern = last_matching_pattern_from_list(pathname, pathlen, basename, + dtype, pl, istate); + if (pattern) { + if (pattern->flags & PATTERN_FLAG_NEGATIVE) + return NOT_MATCHED; + else + return MATCHED; + } + + return UNDECIDED; + } + + if (pl->full_cone) + return MATCHED; + + strbuf_addch(&parent_pathname, '/'); + strbuf_add(&parent_pathname, pathname, pathlen); + + if (hashmap_contains_path(&pl->recursive_hashmap, + &parent_pathname)) { + result = MATCHED_RECURSIVE; + goto done; + } + + slash_pos = strrchr(parent_pathname.buf, '/'); + + if (slash_pos == parent_pathname.buf) { + /* include every file in root */ + result = MATCHED; + goto done; + } + + strbuf_setlen(&parent_pathname, slash_pos - parent_pathname.buf); + + if (hashmap_contains_path(&pl->parent_hashmap, &parent_pathname)) { + result = MATCHED; + goto done; + } + + if (hashmap_contains_parent(&pl->recursive_hashmap, + pathname, + &parent_pathname)) + result = MATCHED_RECURSIVE; + +done: + strbuf_release(&parent_pathname); + return result; } -static struct exclude *last_exclude_matching_from_lists(struct dir_struct *dir, - struct index_state *istate, - const char *pathname, int pathlen, const char *basename, - int *dtype_p) +static struct path_pattern *last_matching_pattern_from_lists( + struct dir_struct *dir, struct index_state *istate, + const char *pathname, int pathlen, + const char *basename, int *dtype_p) { int i, j; struct exclude_list_group *group; - struct exclude *exclude; + struct path_pattern *pattern; for (i = EXC_CMDL; i <= EXC_FILE; i++) { group = &dir->exclude_list_group[i]; for (j = group->nr - 1; j >= 0; j--) { - exclude = last_exclude_matching_from_list( + pattern = last_matching_pattern_from_list( pathname, pathlen, basename, dtype_p, - &group->el[j], istate); - if (exclude) - return exclude; + &group->pl[j], istate); + if (pattern) + return pattern; } } return NULL; @@ -1114,7 +1414,7 @@ static void prep_exclude(struct dir_struct *dir, const char *base, int baselen) { struct exclude_list_group *group; - struct exclude_list *el; + struct pattern_list *pl; struct exclude_stack *stk = NULL; struct untracked_cache_dir *untracked; int current; @@ -1130,17 +1430,17 @@ static void prep_exclude(struct dir_struct *dir, if (stk->baselen <= baselen && !strncmp(dir->basebuf.buf, base, stk->baselen)) break; - el = &group->el[dir->exclude_stack->exclude_ix]; + pl = &group->pl[dir->exclude_stack->exclude_ix]; dir->exclude_stack = stk->prev; - dir->exclude = NULL; - free((char *)el->src); /* see strbuf_detach() below */ - clear_exclude_list(el); + dir->pattern = NULL; + free((char *)pl->src); /* see strbuf_detach() below */ + clear_pattern_list(pl); free(stk); group->nr--; } /* Skip traversing into sub directories if the parent is excluded */ - if (dir->exclude) + if (dir->pattern) return; /* @@ -1181,7 +1481,7 @@ static void prep_exclude(struct dir_struct *dir, stk->baselen = cp - base; stk->exclude_ix = group->nr; stk->ucd = untracked; - el = add_exclude_list(dir, EXC_DIRS, NULL); + pl = add_pattern_list(dir, EXC_DIRS, NULL); strbuf_add(&dir->basebuf, base + current, stk->baselen - current); assert(stk->baselen == dir->basebuf.len); @@ -1189,15 +1489,15 @@ static void prep_exclude(struct dir_struct *dir, if (stk->baselen) { int dt = DT_DIR; dir->basebuf.buf[stk->baselen - 1] = 0; - dir->exclude = last_exclude_matching_from_lists(dir, + dir->pattern = last_matching_pattern_from_lists(dir, istate, dir->basebuf.buf, stk->baselen - 1, dir->basebuf.buf + current, &dt); dir->basebuf.buf[stk->baselen - 1] = '/'; - if (dir->exclude && - dir->exclude->flags & EXC_FLAG_NEGATIVE) - dir->exclude = NULL; - if (dir->exclude) { + if (dir->pattern && + dir->pattern->flags & PATTERN_FLAG_NEGATIVE) + dir->pattern = NULL; + if (dir->pattern) { dir->exclude_stack = stk; return; } @@ -1223,30 +1523,30 @@ static void prep_exclude(struct dir_struct *dir, /* * dir->basebuf gets reused by the traversal, but we * need fname to remain unchanged to ensure the src - * member of each struct exclude correctly + * member of each struct path_pattern correctly * back-references its source file. Other invocations - * of add_exclude_list provide stable strings, so we + * of add_pattern_list provide stable strings, so we * strbuf_detach() and free() here in the caller. */ struct strbuf sb = STRBUF_INIT; strbuf_addbuf(&sb, &dir->basebuf); strbuf_addstr(&sb, dir->exclude_per_dir); - el->src = strbuf_detach(&sb, NULL); - add_excludes(el->src, el->src, stk->baselen, el, istate, + pl->src = strbuf_detach(&sb, NULL); + add_patterns(pl->src, pl->src, stk->baselen, pl, istate, untracked ? &oid_stat : NULL); } /* * NEEDSWORK: when untracked cache is enabled, prep_exclude() * will first be called in valid_cached_dir() then maybe many - * times more in last_exclude_matching(). When the cache is - * used, last_exclude_matching() will not be called and + * times more in last_matching_pattern(). When the cache is + * used, last_matching_pattern() will not be called and * reading .gitignore content will be a waste. * * So when it's called by valid_cached_dir() and we can get * .gitignore SHA-1 from the index (i.e. .gitignore is not * modified on work tree), we could delay reading the * .gitignore content until we absolutely need it in - * last_exclude_matching(). Be careful about ignore rule + * last_matching_pattern(). Be careful about ignore rule * order, though, if you do that. */ if (untracked && @@ -1266,7 +1566,7 @@ static void prep_exclude(struct dir_struct *dir, * Returns the exclude_list element which matched, or NULL for * undecided. */ -struct exclude *last_exclude_matching(struct dir_struct *dir, +struct path_pattern *last_matching_pattern(struct dir_struct *dir, struct index_state *istate, const char *pathname, int *dtype_p) @@ -1277,10 +1577,10 @@ struct exclude *last_exclude_matching(struct dir_struct *dir, prep_exclude(dir, istate, pathname, basename-pathname); - if (dir->exclude) - return dir->exclude; + if (dir->pattern) + return dir->pattern; - return last_exclude_matching_from_lists(dir, istate, pathname, pathlen, + return last_matching_pattern_from_lists(dir, istate, pathname, pathlen, basename, dtype_p); } @@ -1292,10 +1592,10 @@ struct exclude *last_exclude_matching(struct dir_struct *dir, int is_excluded(struct dir_struct *dir, struct index_state *istate, const char *pathname, int *dtype_p) { - struct exclude *exclude = - last_exclude_matching(dir, istate, pathname, dtype_p); - if (exclude) - return exclude->flags & EXC_FLAG_NEGATIVE ? 0 : 1; + struct path_pattern *pattern = + last_matching_pattern(dir, istate, pathname, dtype_p); + if (pattern) + return pattern->flags & PATTERN_FLAG_NEGATIVE ? 0 : 1; return 0; } @@ -1430,6 +1730,8 @@ static enum path_treatment treat_directory(struct dir_struct *dir, const char *dirname, int len, int baselen, int exclude, const struct pathspec *pathspec) { + int nested_repo = 0; + /* The "len-1" is to strip the final '/' */ switch (directory_exists_in_index(istate, dirname, len-1)) { case index_directory: @@ -1439,6 +1741,17 @@ static enum path_treatment treat_directory(struct dir_struct *dir, return path_none; case index_nonexistent: + if ((dir->flags & DIR_SKIP_NESTED_GIT) || + !(dir->flags & DIR_NO_GITLINKS)) { + struct strbuf sb = STRBUF_INIT; + strbuf_addstr(&sb, dirname); + nested_repo = is_nonbare_repository_dir(&sb); + strbuf_release(&sb); + } + if (nested_repo) + return ((dir->flags & DIR_SKIP_NESTED_GIT) ? path_none : + (exclude ? path_excluded : path_untracked)); + if (dir->flags & DIR_SHOW_OTHER_DIRECTORIES) break; if (exclude && @@ -1465,13 +1778,6 @@ static enum path_treatment treat_directory(struct dir_struct *dir, return path_none; } - if (!(dir->flags & DIR_NO_GITLINKS)) { - struct strbuf sb = STRBUF_INIT; - strbuf_addstr(&sb, dirname); - if (is_nonbare_repository_dir(&sb)) - return exclude ? path_excluded : path_untracked; - strbuf_release(&sb); - } return path_recurse; } @@ -1607,10 +1913,9 @@ static int get_index_dtype(struct index_state *istate, return DT_UNKNOWN; } -static int get_dtype(struct dirent *de, struct index_state *istate, - const char *path, int len) +static int resolve_dtype(int dtype, struct index_state *istate, + const char *path, int len) { - int dtype = de ? DTYPE(de) : DT_UNKNOWN; struct stat st; if (dtype != DT_UNKNOWN) @@ -1635,14 +1940,13 @@ static enum path_treatment treat_one_path(struct dir_struct *dir, struct strbuf *path, int baselen, const struct pathspec *pathspec, - int dtype, struct dirent *de) + int dtype) { int exclude; int has_path_in_index = !!index_file_exists(istate, path->buf, path->len, ignore_case); enum path_treatment path_treatment; - if (dtype == DT_UNKNOWN) - dtype = get_dtype(de, istate, path->buf, path->len); + dtype = resolve_dtype(dtype, istate, path->buf, path->len); /* Always exclude indexed files */ if (dtype != DT_DIR && has_path_in_index) @@ -1750,21 +2054,18 @@ static enum path_treatment treat_path(struct dir_struct *dir, int baselen, const struct pathspec *pathspec) { - int dtype; - struct dirent *de = cdir->de; - - if (!de) + if (!cdir->d_name) return treat_path_fast(dir, untracked, cdir, istate, path, baselen, pathspec); - if (is_dot_or_dotdot(de->d_name) || !fspathcmp(de->d_name, ".git")) + if (is_dot_or_dotdot(cdir->d_name) || !fspathcmp(cdir->d_name, ".git")) return path_none; strbuf_setlen(path, baselen); - strbuf_addstr(path, de->d_name); + strbuf_addstr(path, cdir->d_name); if (simplify_away(path->buf, path->len, pathspec)) return path_none; - dtype = DTYPE(de); - return treat_one_path(dir, untracked, istate, path, baselen, pathspec, dtype, de); + return treat_one_path(dir, untracked, istate, path, baselen, pathspec, + cdir->d_type); } static void add_untracked(struct untracked_cache_dir *dir, const char *name) @@ -1808,7 +2109,7 @@ static int valid_cached_dir(struct dir_struct *dir, /* * prep_exclude will be called eventually on this directory, - * but it's called much later in last_exclude_matching(). We + * but it's called much later in last_matching_pattern(). We * need it now to determine the validity of the cache for this * path. The next calls will be nearly no-op, the way * prep_exclude() is designed. @@ -1852,10 +2153,17 @@ static int open_cached_dir(struct cached_dir *cdir, static int read_cached_dir(struct cached_dir *cdir) { + struct dirent *de; + if (cdir->fdir) { - cdir->de = readdir(cdir->fdir); - if (!cdir->de) + de = readdir(cdir->fdir); + if (!de) { + cdir->d_name = NULL; + cdir->d_type = DT_UNKNOWN; return -1; + } + cdir->d_name = de->d_name; + cdir->d_type = DTYPE(de); return 0; } while (cdir->nr_dirs < cdir->untracked->dirs_nr) { @@ -1891,6 +2199,40 @@ static void close_cached_dir(struct cached_dir *cdir) } } +static void add_path_to_appropriate_result_list(struct dir_struct *dir, + struct untracked_cache_dir *untracked, + struct cached_dir *cdir, + struct index_state *istate, + struct strbuf *path, + int baselen, + const struct pathspec *pathspec, + enum path_treatment state) +{ + /* add the path to the appropriate result list */ + switch (state) { + case path_excluded: + if (dir->flags & DIR_SHOW_IGNORED) + dir_add_name(dir, istate, path->buf, path->len); + else if ((dir->flags & DIR_SHOW_IGNORED_TOO) || + ((dir->flags & DIR_COLLECT_IGNORED) && + exclude_matches_pathspec(path->buf, path->len, + pathspec))) + dir_add_ignored(dir, istate, path->buf, path->len); + break; + + case path_untracked: + if (dir->flags & DIR_SHOW_IGNORED) + break; + dir_add_name(dir, istate, path->buf, path->len); + if (cdir->fdir) + add_untracked(untracked, path->buf + baselen); + break; + + default: + break; + } +} + /* * Read a directory tree. We currently ignore anything but * directories, regular files and symlinks. That's because git @@ -1915,6 +2257,15 @@ static enum path_treatment read_directory_recursive(struct dir_struct *dir, struct untracked_cache_dir *untracked, int check_only, int stop_at_first_file, const struct pathspec *pathspec) { + /* + * WARNING WARNING WARNING: + * + * Any updates to the traversal logic here may need corresponding + * updates in treat_leading_path(). See the commit message for the + * commit adding this warning as well as the commit preceding it + * for details. + */ + struct cached_dir cdir; enum path_treatment state, subdir_state, dir_state = path_none; struct strbuf path = STRBUF_INIT; @@ -1938,8 +2289,11 @@ static enum path_treatment read_directory_recursive(struct dir_struct *dir, /* recurse into subdir if instructed by treat_path */ if ((state == path_recurse) || ((state == path_untracked) && - (dir->flags & DIR_SHOW_IGNORED_TOO) && - (get_dtype(cdir.de, istate, path.buf, path.len) == DT_DIR))) { + (resolve_dtype(cdir.d_type, istate, path.buf, path.len) == DT_DIR) && + ((dir->flags & DIR_SHOW_IGNORED_TOO) || + (pathspec && + do_match_pathspec(istate, pathspec, path.buf, path.len, + baselen, NULL, DO_MATCH_LEADING_PATHSPEC) == MATCHED_RECURSIVELY_LEADING_PATHSPEC)))) { struct untracked_cache_dir *ud; ud = lookup_untracked(dir->untracked, untracked, path.buf + baselen, @@ -1950,6 +2304,12 @@ static enum path_treatment read_directory_recursive(struct dir_struct *dir, check_only, stop_at_first_file, pathspec); if (subdir_state > dir_state) dir_state = subdir_state; + + if (pathspec && + !match_pathspec(istate, pathspec, path.buf, path.len, + 0 /* prefix */, NULL, + 0 /* do NOT special case dirs */)) + state = path_none; } if (check_only) { @@ -1985,29 +2345,9 @@ static enum path_treatment read_directory_recursive(struct dir_struct *dir, continue; } - /* add the path to the appropriate result list */ - switch (state) { - case path_excluded: - if (dir->flags & DIR_SHOW_IGNORED) - dir_add_name(dir, istate, path.buf, path.len); - else if ((dir->flags & DIR_SHOW_IGNORED_TOO) || - ((dir->flags & DIR_COLLECT_IGNORED) && - exclude_matches_pathspec(path.buf, path.len, - pathspec))) - dir_add_ignored(dir, istate, path.buf, path.len); - break; - - case path_untracked: - if (dir->flags & DIR_SHOW_IGNORED) - break; - dir_add_name(dir, istate, path.buf, path.len); - if (cdir.fdir) - add_untracked(untracked, path.buf + baselen); - break; - - default: - break; - } + add_path_to_appropriate_result_list(dir, untracked, &cdir, + istate, &path, baselen, + pathspec, state); } close_cached_dir(&cdir); out: @@ -2037,41 +2377,95 @@ static int treat_leading_path(struct dir_struct *dir, const char *path, int len, const struct pathspec *pathspec) { + /* + * WARNING WARNING WARNING: + * + * Any updates to the traversal logic here may need corresponding + * updates in read_directory_recursive(). See 777b420347 (dir: + * synchronize treat_leading_path() and read_directory_recursive(), + * 2019-12-19) and its parent commit for details. + */ + struct strbuf sb = STRBUF_INIT; - int baselen, rc = 0; + struct strbuf subdir = STRBUF_INIT; + int prevlen, baselen; const char *cp; - int old_flags = dir->flags; + struct cached_dir cdir; + enum path_treatment state = path_none; + + /* + * For each directory component of path, we are going to check whether + * that path is relevant given the pathspec. For example, if path is + * foo/bar/baz/ + * then we will ask treat_path() whether we should go into foo, then + * whether we should go into bar, then whether baz is relevant. + * Checking each is important because e.g. if path is + * .git/info/ + * then we need to check .git to know we shouldn't traverse it. + * If the return from treat_path() is: + * * path_none, for any path, we return false. + * * path_recurse, for all path components, we return true + * * <anything else> for some intermediate component, we make sure + * to add that path to the relevant list but return false + * signifying that we shouldn't recurse into it. + */ while (len && path[len - 1] == '/') len--; if (!len) return 1; + + memset(&cdir, 0, sizeof(cdir)); + cdir.d_type = DT_DIR; baselen = 0; - dir->flags &= ~DIR_SHOW_OTHER_DIRECTORIES; + prevlen = 0; while (1) { - cp = path + baselen + !!baselen; + prevlen = baselen + !!baselen; + cp = path + prevlen; cp = memchr(cp, '/', path + len - cp); if (!cp) baselen = len; else baselen = cp - path; - strbuf_setlen(&sb, 0); + strbuf_reset(&sb); strbuf_add(&sb, path, baselen); if (!is_directory(sb.buf)) break; - if (simplify_away(sb.buf, sb.len, pathspec)) - break; - if (treat_one_path(dir, NULL, istate, &sb, baselen, pathspec, - DT_DIR, NULL) == path_none) + strbuf_reset(&sb); + strbuf_add(&sb, path, prevlen); + strbuf_reset(&subdir); + strbuf_add(&subdir, path+prevlen, baselen-prevlen); + cdir.d_name = subdir.buf; + state = treat_path(dir, NULL, &cdir, istate, &sb, prevlen, + pathspec); + if (state == path_untracked && + resolve_dtype(cdir.d_type, istate, sb.buf, sb.len) == DT_DIR && + (dir->flags & DIR_SHOW_IGNORED_TOO || + do_match_pathspec(istate, pathspec, sb.buf, sb.len, + baselen, NULL, DO_MATCH_LEADING_PATHSPEC) == MATCHED_RECURSIVELY_LEADING_PATHSPEC)) { + if (!match_pathspec(istate, pathspec, sb.buf, sb.len, + 0 /* prefix */, NULL, + 0 /* do NOT special case dirs */)) + state = path_none; + add_path_to_appropriate_result_list(dir, NULL, &cdir, + istate, + &sb, baselen, + pathspec, state); + state = path_recurse; + } + + if (state != path_recurse) break; /* do not recurse into it */ - if (len <= baselen) { - rc = 1; + if (len <= baselen) break; /* finished checking */ - } } + add_path_to_appropriate_result_list(dir, NULL, &cdir, istate, + &sb, baselen, pathspec, + state); + + strbuf_release(&subdir); strbuf_release(&sb); - dir->flags = old_flags; - return rc; + return state == path_recurse; } static const char *get_ident_string(void) @@ -2446,7 +2840,7 @@ static int remove_dir_recurse(struct strbuf *path, int flag, int *kept_up) * wanted anyway */ continue; - /* fall thru */ + /* fall through */ } else if (S_ISDIR(st.st_mode)) { if (!remove_dir_recurse(path, flag, &kept_down)) continue; /* happy */ @@ -2488,14 +2882,14 @@ void setup_standard_excludes(struct dir_struct *dir) if (!excludes_file) excludes_file = xdg_config_home("ignore"); if (excludes_file && !access_or_warn(excludes_file, R_OK, 0)) - add_excludes_from_file_1(dir, excludes_file, + add_patterns_from_file_1(dir, excludes_file, dir->untracked ? &dir->ss_excludes_file : NULL); /* per repository user preference */ if (startup_info->have_repository) { const char *path = git_path_info_exclude(); if (!access_or_warn(path, R_OK, 0)) - add_excludes_from_file_1(dir, path, + add_patterns_from_file_1(dir, path, dir->untracked ? &dir->ss_info_exclude : NULL); } } @@ -2527,18 +2921,18 @@ void clear_directory(struct dir_struct *dir) { int i, j; struct exclude_list_group *group; - struct exclude_list *el; + struct pattern_list *pl; struct exclude_stack *stk; for (i = EXC_CMDL; i <= EXC_FILE; i++) { group = &dir->exclude_list_group[i]; for (j = 0; j < group->nr; j++) { - el = &group->el[j]; + pl = &group->pl[j]; if (i == EXC_DIRS) - free((char *)el->src); - clear_exclude_list(el); + free((char *)pl->src); + clear_pattern_list(pl); } - free(group->el); + free(group->pl); } stk = dir->exclude_stack; |