kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

treewide: rename 'exclude' methods to 'pattern' 

The first consumer of pattern-matching filenames was the
.gitignore feature. In that context, storing a list of patterns
as a 'struct exclude_list'  makes sense. However, the
sparse-checkout feature then adopted these structures and methods,
but with the opposite meaning: these patterns match the files
that should be included!

It would be clearer to rename this entire library as a "pattern
matching" library, and the callers apply exclusion/inclusion
logic accordingly based on their needs.

This commit renames several methods defined in dir.h to make
more sense with the renamed 'struct exclude_list' to 'struct
pattern_list' and 'struct exclude' to 'struct path_pattern':

 * last_exclude_matching() -> last_matching_pattern()
 * parse_exclude() -> parse_path_pattern()

In addition, the word 'exclude' was replaced with 'pattern'
in the methods below:

 * add_exclude_list()
 * add_excludes_from_file_to_list()
 * add_excludes_from_file()
 * add_excludes_from_blob_to_list()
 * add_exclude()
 * clear_exclude_list()

A few methods with the word "exclude" remain. These will
be handled seperately. In particular, the method
"is_excluded()" is concretely about the .gitignore file
relative to a specific directory. This is the important
boundary between library and consumer: is_excluded() cares
about .gitignore, but is_excluded() calls
last_matching_pattern() to make that decision.

Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
maint
Derrick Stolee 2019-09-03 11:04:57 -07:00 committed by Junio C Hamano
parent 4ff89ee52c
commit 65edd96aec
11 changed files with 67 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Documentation/RelNotes/2.7.1.txt
View File

@ -10,7 +10,7 @@ Fixes since v2.7
setting GIT_WORK_TREE environment themselves. setting GIT_WORK_TREE environment themselves.


* The "exclude_list" structure has the usual "alloc, nr" pair of * The "exclude_list" structure has the usual "alloc, nr" pair of
fields to be used by ALLOC_GROW(), but clear_exclude_list() forgot fields to be used by ALLOC_GROW(), but clear_pattern_list() forgot
to reset 'alloc' to 0 when it cleared 'nr' to discard the managed to reset 'alloc' to 0 when it cleared 'nr' to discard the managed
array. array.



2
Documentation/RelNotes/2.8.0.txt
View File

@ -270,7 +270,7 @@ notes for details).
setting GIT_WORK_TREE environment themselves. setting GIT_WORK_TREE environment themselves.


* The "exclude_list" structure has the usual "alloc, nr" pair of * The "exclude_list" structure has the usual "alloc, nr" pair of
fields to be used by ALLOC_GROW(), but clear_exclude_list() forgot fields to be used by ALLOC_GROW(), but clear_pattern_list() forgot
to reset 'alloc' to 0 when it cleared 'nr' to discard the managed to reset 'alloc' to 0 when it cleared 'nr' to discard the managed
array. array.



6
Documentation/technical/api-directory-listing.txt
View File

@ -111,11 +111,11 @@ marked. If you to exclude files, make sure you have loaded index first.
* Prepare `struct dir_struct dir` and clear it with `memset(&dir, 0, * Prepare `struct dir_struct dir` and clear it with `memset(&dir, 0,
sizeof(dir))`. sizeof(dir))`.


* To add single exclude pattern, call `add_exclude_list()` and then * To add single exclude pattern, call `add_pattern_list()` and then
`add_exclude()`. `add_pattern()`.


* To add patterns from a file (e.g. `.git/info/exclude`), call * To add patterns from a file (e.g. `.git/info/exclude`), call
`add_excludes_from_file()` , and/or set `dir.exclude_per_dir`. A `add_patterns_from_file()` , and/or set `dir.exclude_per_dir`. A
short-hand function `setup_standard_excludes()` can be used to set short-hand function `setup_standard_excludes()` can be used to set
up the standard set of exclude settings. up the standard set of exclude settings.



2
attr.c
View File

@ -400,7 +400,7 @@ static struct match_attr *parse_attr_line(const char *line, const char *src,
char *p = (char *)&(res->state[num_attr]); char *p = (char *)&(res->state[num_attr]);
memcpy(p, name, namelen); memcpy(p, name, namelen);
res->u.pat.pattern = p; res->u.pat.pattern = p;
parse_exclude_pattern(&res->u.pat.pattern, parse_path_pattern(&res->u.pat.pattern,
&res->u.pat.patternlen, &res->u.pat.patternlen,
&res->u.pat.flags, &res->u.pat.flags,
&res->u.pat.nowildcardlen); &res->u.pat.nowildcardlen);

2
builtin/check-ignore.c
View File

@ -106,7 +106,7 @@ static int check_ignore(struct dir_struct *dir,
pattern = NULL; pattern = NULL;
if (!seen[i]) { if (!seen[i]) {
int dtype = DT_UNKNOWN; int dtype = DT_UNKNOWN;
pattern = last_exclude_matching(dir, &the_index, pattern = last_matching_pattern(dir, &the_index,
full_path, &dtype); full_path, &dtype);
} }
if (!quiet && (pattern || show_non_matching)) if (!quiet && (pattern || show_non_matching))

8
builtin/clean.c
View File

@ -670,7 +670,7 @@ static int filter_by_patterns_cmd(void)
break; break;


memset(&dir, 0, sizeof(dir)); memset(&dir, 0, sizeof(dir));
pl = add_exclude_list(&dir, EXC_CMDL, "manual exclude"); pl = add_pattern_list(&dir, EXC_CMDL, "manual exclude");
ignore_list = strbuf_split_max(&confirm, ' ', 0); ignore_list = strbuf_split_max(&confirm, ' ', 0);


for (i = 0; ignore_list[i]; i++) { for (i = 0; ignore_list[i]; i++) {
@ -678,7 +678,7 @@ static int filter_by_patterns_cmd(void)
if (!ignore_list[i]->len) if (!ignore_list[i]->len)
continue; continue;


add_exclude(ignore_list[i]->buf, "", 0, pl, -(i+1)); add_pattern(ignore_list[i]->buf, "", 0, pl, -(i+1));
} }


changed = 0; changed = 0;
@ -957,9 +957,9 @@ int cmd_clean(int argc, const char **argv, const char *prefix)
if (!ignored) if (!ignored)
setup_standard_excludes(&dir); setup_standard_excludes(&dir);


pl = add_exclude_list(&dir, EXC_CMDL, "--exclude option"); pl = add_pattern_list(&dir, EXC_CMDL, "--exclude option");
for (i = 0; i < exclude_list.nr; i++) for (i = 0; i < exclude_list.nr; i++)
add_exclude(exclude_list.items[i].string, "", 0, pl, -(i+1)); add_pattern(exclude_list.items[i].string, "", 0, pl, -(i+1));


parse_pathspec(&pathspec, 0, parse_pathspec(&pathspec, 0,
PATHSPEC_PREFER_CWD, PATHSPEC_PREFER_CWD,

6
builtin/ls-files.c
View File

@ -492,7 +492,7 @@ static int option_parse_exclude_from(const struct option *opt,
BUG_ON_OPT_NEG(unset); BUG_ON_OPT_NEG(unset);


exc_given = 1; exc_given = 1;
add_excludes_from_file(dir, arg); add_patterns_from_file(dir, arg);


return 0; return 0;
} }
@ -594,9 +594,9 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)


argc = parse_options(argc, argv, prefix, builtin_ls_files_options, argc = parse_options(argc, argv, prefix, builtin_ls_files_options,
ls_files_usage, 0); ls_files_usage, 0);
pl = add_exclude_list(&dir, EXC_CMDL, "--exclude option"); pl = add_pattern_list(&dir, EXC_CMDL, "--exclude option");
for (i = 0; i < exclude_list.nr; i++) { for (i = 0; i < exclude_list.nr; i++) {
add_exclude(exclude_list.items[i].string, "", 0, pl, --exclude_args); add_pattern(exclude_list.items[i].string, "", 0, pl, --exclude_args);
} }
if (show_tag || show_valid_bit || show_fsmonitor_bit) { if (show_tag || show_valid_bit || show_fsmonitor_bit) {
tag_cached = "H "; tag_cached = "H ";

78
dir.c
View File

@ -561,7 +561,7 @@ int no_wildcard(const char *string)
return string[simple_length(string)] == '\0'; return string[simple_length(string)] == '\0';
} }


void parse_exclude_pattern(const char **pattern, void parse_path_pattern(const char **pattern,
int *patternlen, int *patternlen,
unsigned *flags, unsigned *flags,
int *nowildcardlen) int *nowildcardlen)
@ -599,7 +599,7 @@ void parse_exclude_pattern(const char **pattern,
*patternlen = len; *patternlen = len;
} }


void add_exclude(const char *string, const char *base, void add_pattern(const char *string, const char *base,
int baselen, struct pattern_list *pl, int srcpos) int baselen, struct pattern_list *pl, int srcpos)
{ {
struct path_pattern *pattern; struct path_pattern *pattern;
@ -607,7 +607,7 @@ void add_exclude(const char *string, const char *base,
unsigned flags; unsigned flags;
int nowildcardlen; int nowildcardlen;


parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen); parse_path_pattern(&string, &patternlen, &flags, &nowildcardlen);
if (flags & PATTERN_FLAG_MUSTBEDIR) { if (flags & PATTERN_FLAG_MUSTBEDIR) {
FLEXPTR_ALLOC_MEM(pattern, pattern, string, patternlen); FLEXPTR_ALLOC_MEM(pattern, pattern, string, patternlen);
} else { } else {
@ -646,7 +646,7 @@ static int read_skip_worktree_file_from_index(const struct index_state *istate,
* Frees memory within pl which was allocated for exclude patterns and * Frees memory within pl which was allocated for exclude patterns and
* the file buffer. Does not free pl itself. * the file buffer. Does not free pl itself.
*/ */
void clear_exclude_list(struct pattern_list *pl) void clear_pattern_list(struct pattern_list *pl)
{ {
int i; int i;


@ -762,7 +762,7 @@ static void invalidate_directory(struct untracked_cache *uc,
dir->dirs[i]->recurse = 0; 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, const char *base, int baselen,
struct pattern_list *pl); struct pattern_list *pl);


@ -772,10 +772,10 @@ static int add_excludes_from_buffer(char *buf, size_t size,
* exclude rules in "pl". * exclude rules in "pl".
* *
* If "ss" is not NULL, compute SHA-1 of the exclude file and fill * 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. * ss_valid is non-zero, "ss" must contain good value as input.
*/ */
static int add_excludes(const char *fname, const char *base, int baselen, static int add_patterns(const char *fname, const char *base, int baselen,
struct pattern_list *pl, struct index_state *istate, struct pattern_list *pl, struct index_state *istate,
struct oid_stat *oid_stat) struct oid_stat *oid_stat)
{ {
@ -837,11 +837,11 @@ static int add_excludes(const char *fname, const char *base, int baselen,
} }
} }


add_excludes_from_buffer(buf, size, base, baselen, pl); add_patterns_from_buffer(buf, size, base, baselen, pl);
return 0; 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, const char *base, int baselen,
struct pattern_list *pl) struct pattern_list *pl)
{ {
@ -860,7 +860,7 @@ static int add_excludes_from_buffer(char *buf, size_t size,
if (entry != buf + i && entry[0] != '#') { if (entry != buf + i && entry[0] != '#') {
buf[i - (i && buf[i-1] == '\r')] = 0; buf[i - (i && buf[i-1] == '\r')] = 0;
trim_trailing_spaces(entry); trim_trailing_spaces(entry);
add_exclude(entry, base, baselen, pl, lineno); add_pattern(entry, base, baselen, pl, lineno);
} }
lineno++; lineno++;
entry = buf + i + 1; entry = buf + i + 1;
@ -869,14 +869,14 @@ static int add_excludes_from_buffer(char *buf, size_t size,
return 0; return 0;
} }


int add_excludes_from_file_to_list(const char *fname, const char *base, int add_patterns_from_file_to_list(const char *fname, const char *base,
int baselen, struct pattern_list *pl, int baselen, struct pattern_list *pl,
struct index_state *istate) struct index_state *istate)
{ {
return add_excludes(fname, base, baselen, pl, 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, struct object_id *oid,
const char *base, int baselen, const char *base, int baselen,
struct pattern_list *pl) struct pattern_list *pl)
@ -889,11 +889,11 @@ int add_excludes_from_blob_to_list(
if (r != 1) if (r != 1)
return r; return r;


add_excludes_from_buffer(buf, size, base, baselen, pl); add_patterns_from_buffer(buf, size, base, baselen, pl);
return 0; return 0;
} }


struct pattern_list *add_exclude_list(struct dir_struct *dir, struct pattern_list *add_pattern_list(struct dir_struct *dir,
int group_type, const char *src) int group_type, const char *src)
{ {
struct pattern_list *pl; struct pattern_list *pl;
@ -910,7 +910,7 @@ struct pattern_list *add_exclude_list(struct dir_struct *dir,
/* /*
* Used to set up core.excludesfile and .git/info/exclude lists. * 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 oid_stat *oid_stat)
{ {
struct pattern_list *pl; struct pattern_list *pl;
@ -921,15 +921,15 @@ static void add_excludes_from_file_1(struct dir_struct *dir, const char *fname,
*/ */
if (!dir->untracked) if (!dir->untracked)
dir->unmanaged_exclude_files++; dir->unmanaged_exclude_files++;
pl = add_exclude_list(dir, EXC_FILE, fname); pl = add_pattern_list(dir, EXC_FILE, fname);
if (add_excludes(fname, "", 0, pl, NULL, oid_stat) < 0) if (add_patterns(fname, "", 0, pl, NULL, oid_stat) < 0)
die(_("cannot use %s as an exclude file"), fname); 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() */ 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, int match_basename(const char *basename, int basenamelen,
@ -1021,7 +1021,7 @@ int match_pathname(const char *pathname, int pathlen,
* any, determines the fate. Returns the exclude_list element which * any, determines the fate. Returns the exclude_list element which
* matched, or NULL for undecided. * matched, or NULL for undecided.
*/ */
static struct path_pattern *last_exclude_matching_from_list(const char *pathname, static struct path_pattern *last_matching_pattern_from_list(const char *pathname,
int pathlen, int pathlen,
const char *basename, const char *basename,
int *dtype, int *dtype,
@ -1080,14 +1080,14 @@ int is_excluded_from_list(const char *pathname,
struct pattern_list *pl, struct index_state *istate) struct pattern_list *pl, struct index_state *istate)
{ {
struct path_pattern *pattern; struct path_pattern *pattern;
pattern = last_exclude_matching_from_list(pathname, pathlen, basename, pattern = last_matching_pattern_from_list(pathname, pathlen, basename,
dtype, pl, istate); dtype, pl, istate);
if (pattern) if (pattern)
return pattern->flags & PATTERN_FLAG_NEGATIVE ? 0 : 1; return pattern->flags & PATTERN_FLAG_NEGATIVE ? 0 : 1;
return -1; /* undecided */ return -1; /* undecided */
} }


static struct path_pattern *last_exclude_matching_from_lists( static struct path_pattern *last_matching_pattern_from_lists(
struct dir_struct *dir, struct index_state *istate, struct dir_struct *dir, struct index_state *istate,
const char *pathname, int pathlen, const char *pathname, int pathlen,
const char *basename, int *dtype_p) const char *basename, int *dtype_p)
@ -1098,7 +1098,7 @@ static struct path_pattern *last_exclude_matching_from_lists(
for (i = EXC_CMDL; i <= EXC_FILE; i++) { for (i = EXC_CMDL; i <= EXC_FILE; i++) {
group = &dir->exclude_list_group[i]; group = &dir->exclude_list_group[i];
for (j = group->nr - 1; j >= 0; j--) { for (j = group->nr - 1; j >= 0; j--) {
pattern = last_exclude_matching_from_list( pattern = last_matching_pattern_from_list(
pathname, pathlen, basename, dtype_p, pathname, pathlen, basename, dtype_p,
&group->pl[j], istate); &group->pl[j], istate);
if (pattern) if (pattern)
@ -1137,7 +1137,7 @@ static void prep_exclude(struct dir_struct *dir,
dir->exclude_stack = stk->prev; dir->exclude_stack = stk->prev;
dir->pattern = NULL; dir->pattern = NULL;
free((char *)pl->src); /* see strbuf_detach() below */ free((char *)pl->src); /* see strbuf_detach() below */
clear_exclude_list(pl); clear_pattern_list(pl);
free(stk); free(stk);
group->nr--; group->nr--;
} }
@ -1184,7 +1184,7 @@ static void prep_exclude(struct dir_struct *dir,
stk->baselen = cp - base; stk->baselen = cp - base;
stk->exclude_ix = group->nr; stk->exclude_ix = group->nr;
stk->ucd = untracked; stk->ucd = untracked;
pl = add_exclude_list(dir, EXC_DIRS, NULL); pl = add_pattern_list(dir, EXC_DIRS, NULL);
strbuf_add(&dir->basebuf, base + current, stk->baselen - current); strbuf_add(&dir->basebuf, base + current, stk->baselen - current);
assert(stk->baselen == dir->basebuf.len); assert(stk->baselen == dir->basebuf.len);


@ -1192,7 +1192,7 @@ static void prep_exclude(struct dir_struct *dir,
if (stk->baselen) { if (stk->baselen) {
int dt = DT_DIR; int dt = DT_DIR;
dir->basebuf.buf[stk->baselen - 1] = 0; dir->basebuf.buf[stk->baselen - 1] = 0;
dir->pattern = last_exclude_matching_from_lists(dir, dir->pattern = last_matching_pattern_from_lists(dir,
istate, istate,
dir->basebuf.buf, stk->baselen - 1, dir->basebuf.buf, stk->baselen - 1,
dir->basebuf.buf + current, &dt); dir->basebuf.buf + current, &dt);
@ -1228,28 +1228,28 @@ static void prep_exclude(struct dir_struct *dir,
* need fname to remain unchanged to ensure the src * need fname to remain unchanged to ensure the src
* member of each struct path_pattern correctly * member of each struct path_pattern correctly
* back-references its source file. Other invocations * 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. * strbuf_detach() and free() here in the caller.
*/ */
struct strbuf sb = STRBUF_INIT; struct strbuf sb = STRBUF_INIT;
strbuf_addbuf(&sb, &dir->basebuf); strbuf_addbuf(&sb, &dir->basebuf);
strbuf_addstr(&sb, dir->exclude_per_dir); strbuf_addstr(&sb, dir->exclude_per_dir);
pl->src = strbuf_detach(&sb, NULL); pl->src = strbuf_detach(&sb, NULL);
add_excludes(pl->src, pl->src, stk->baselen, pl, istate, add_patterns(pl->src, pl->src, stk->baselen, pl, istate,
untracked ? &oid_stat : NULL); untracked ? &oid_stat : NULL);
} }
/* /*
* NEEDSWORK: when untracked cache is enabled, prep_exclude() * NEEDSWORK: when untracked cache is enabled, prep_exclude()
* will first be called in valid_cached_dir() then maybe many * will first be called in valid_cached_dir() then maybe many
* times more in last_exclude_matching(). When the cache is * times more in last_matching_pattern(). When the cache is
* used, last_exclude_matching() will not be called and * used, last_matching_pattern() will not be called and
* reading .gitignore content will be a waste. * reading .gitignore content will be a waste.
* *
* So when it's called by valid_cached_dir() and we can get * So when it's called by valid_cached_dir() and we can get
* .gitignore SHA-1 from the index (i.e. .gitignore is not * .gitignore SHA-1 from the index (i.e. .gitignore is not
* modified on work tree), we could delay reading the * modified on work tree), we could delay reading the
* .gitignore content until we absolutely need it in * .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. * order, though, if you do that.
*/ */
if (untracked && if (untracked &&
@ -1269,7 +1269,7 @@ static void prep_exclude(struct dir_struct *dir,
* Returns the exclude_list element which matched, or NULL for * Returns the exclude_list element which matched, or NULL for
* undecided. * undecided.
*/ */
struct path_pattern *last_exclude_matching(struct dir_struct *dir, struct path_pattern *last_matching_pattern(struct dir_struct *dir,
struct index_state *istate, struct index_state *istate,
const char *pathname, const char *pathname,
int *dtype_p) int *dtype_p)
@ -1283,7 +1283,7 @@ struct path_pattern *last_exclude_matching(struct dir_struct *dir,
if (dir->pattern) if (dir->pattern)
return 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); basename, dtype_p);
} }


@ -1296,7 +1296,7 @@ int is_excluded(struct dir_struct *dir, struct index_state *istate,
const char *pathname, int *dtype_p) const char *pathname, int *dtype_p)
{ {
struct path_pattern *pattern = struct path_pattern *pattern =
last_exclude_matching(dir, istate, pathname, dtype_p); last_matching_pattern(dir, istate, pathname, dtype_p);
if (pattern) if (pattern)
return pattern->flags & PATTERN_FLAG_NEGATIVE ? 0 : 1; return pattern->flags & PATTERN_FLAG_NEGATIVE ? 0 : 1;
return 0; return 0;
@ -1811,7 +1811,7 @@ static int valid_cached_dir(struct dir_struct *dir,


/* /*
* prep_exclude will be called eventually on this directory, * 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 * need it now to determine the validity of the cache for this
* path. The next calls will be nearly no-op, the way * path. The next calls will be nearly no-op, the way
* prep_exclude() is designed. * prep_exclude() is designed.
@ -2491,14 +2491,14 @@ void setup_standard_excludes(struct dir_struct *dir)
if (!excludes_file) if (!excludes_file)
excludes_file = xdg_config_home("ignore"); excludes_file = xdg_config_home("ignore");
if (excludes_file && !access_or_warn(excludes_file, R_OK, 0)) 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); dir->untracked ? &dir->ss_excludes_file : NULL);


/* per repository user preference */ /* per repository user preference */
if (startup_info->have_repository) { if (startup_info->have_repository) {
const char *path = git_path_info_exclude(); const char *path = git_path_info_exclude();
if (!access_or_warn(path, R_OK, 0)) 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); dir->untracked ? &dir->ss_info_exclude : NULL);
} }
} }
@ -2539,7 +2539,7 @@ void clear_directory(struct dir_struct *dir)
pl = &group->pl[j]; pl = &group->pl[j];
if (i == EXC_DIRS) if (i == EXC_DIRS)
free((char *)pl->src); free((char *)pl->src);
clear_exclude_list(pl); clear_pattern_list(pl);
} }
free(group->pl); free(group->pl);
} }

22
dir.h
View File

@ -18,7 +18,7 @@ struct dir_entry {


struct path_pattern { struct path_pattern {
/* /*
* This allows callers of last_exclude_matching() etc. * This allows callers of last_matching_pattern() etc.
* to determine the origin of the matching pattern. * to determine the origin of the matching pattern.
*/ */
struct pattern_list *pl; struct pattern_list *pl;
@ -248,26 +248,26 @@ int match_pathname(const char *, int,
const char *, int, const char *, int,
const char *, int, int, unsigned); const char *, int, int, unsigned);


struct path_pattern *last_exclude_matching(struct dir_struct *dir, struct path_pattern *last_matching_pattern(struct dir_struct *dir,
struct index_state *istate, struct index_state *istate,
const char *name, int *dtype); const char *name, int *dtype);


int is_excluded(struct dir_struct *dir, int is_excluded(struct dir_struct *dir,
struct index_state *istate, struct index_state *istate,
const char *name, int *dtype); const char *name, int *dtype);


struct pattern_list *add_exclude_list(struct dir_struct *dir, struct pattern_list *add_pattern_list(struct dir_struct *dir,
int group_type, const char *src); int group_type, const char *src);
int add_excludes_from_file_to_list(const char *fname, const char *base, int baselen, int add_patterns_from_file_to_list(const char *fname, const char *base, int baselen,
struct pattern_list *pl, struct index_state *istate); struct pattern_list *pl, struct index_state *istate);
void add_excludes_from_file(struct dir_struct *, const char *fname); void add_patterns_from_file(struct dir_struct *, const char *fname);
int add_excludes_from_blob_to_list(struct object_id *oid, int add_patterns_from_blob_to_list(struct object_id *oid,
const char *base, int baselen, const char *base, int baselen,
struct pattern_list *pl); struct pattern_list *pl);
void parse_exclude_pattern(const char **string, int *patternlen, unsigned *flags, int *nowildcardlen); void parse_path_pattern(const char **string, int *patternlen, unsigned *flags, int *nowildcardlen);
void add_exclude(const char *string, const char *base, void add_pattern(const char *string, const char *base,
int baselen, struct pattern_list *pl, int srcpos); int baselen, struct pattern_list *pl, int srcpos);
void clear_exclude_list(struct pattern_list *pl); void clear_pattern_list(struct pattern_list *pl);
void clear_directory(struct dir_struct *dir); void clear_directory(struct dir_struct *dir);


int repo_file_exists(struct repository *repo, const char *path); int repo_file_exists(struct repository *repo, const char *path);

2
list-objects-filter.c
View File

@ -482,7 +482,7 @@ static void filter_sparse_oid__init(
struct filter *filter) struct filter *filter)
{ {
struct filter_sparse_data *d = xcalloc(1, sizeof(*d)); struct filter_sparse_data *d = xcalloc(1, sizeof(*d));
if (add_excludes_from_blob_to_list(filter_options->sparse_oid_value, if (add_patterns_from_blob_to_list(filter_options->sparse_oid_value,
NULL, 0, &d->pl) < 0) NULL, 0, &d->pl) < 0)
die("could not load filter specification"); die("could not load filter specification");



4
unpack-trees.c
View File

@ -1464,7 +1464,7 @@ int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options
o->skip_sparse_checkout = 1; o->skip_sparse_checkout = 1;
if (!o->skip_sparse_checkout) { if (!o->skip_sparse_checkout) {
char *sparse = git_pathdup("info/sparse-checkout"); char *sparse = git_pathdup("info/sparse-checkout");
if (add_excludes_from_file_to_list(sparse, "", 0, &pl, NULL) < 0) if (add_patterns_from_file_to_list(sparse, "", 0, &pl, NULL) < 0)
o->skip_sparse_checkout = 1; o->skip_sparse_checkout = 1;
else else
o->pl = &pl; o->pl = &pl;
@ -1631,7 +1631,7 @@ int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options


done: done:
trace_performance_leave("unpack_trees"); trace_performance_leave("unpack_trees");
clear_exclude_list(&pl); clear_pattern_list(&pl);
return ret; return ret;


return_failed: return_failed: