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>

diff --git a/Documentation/RelNotes/2.7.1.txt b/Documentation/RelNotes/2.7.1.txt
index 6553d69e332ce95ba194a156518fa9f69d7d24f0..6323feaf6497458cd196369fa3036d4260b81c29 100644 (file)
--- a/Documentation/RelNotes/2.7.1.txt
+++ b/Documentation/RelNotes/2.7.1.txt
@@ -10,7 +10,7 @@ Fixes since v2.7
    setting GIT_WORK_TREE environment themselves.
 
  * The "exclude_list" structure has the usual "alloc, nr" pair of
    setting GIT_WORK_TREE environment themselves.
 
  * 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
    array.
 
    to reset 'alloc' to 0 when it cleared 'nr' to discard the managed
    array.
 

diff --git a/Documentation/RelNotes/2.8.0.txt b/Documentation/RelNotes/2.8.0.txt
index 25079710fa28155cf8d2747d9cbca14fcd84f360..5fbe1b86eeaca111ecef74b909c361172ca506ba 100644 (file)
--- a/Documentation/RelNotes/2.8.0.txt
+++ b/Documentation/RelNotes/2.8.0.txt
@@ -270,7 +270,7 @@ notes for details).
    setting GIT_WORK_TREE environment themselves.
 
  * The "exclude_list" structure has the usual "alloc, nr" pair of
    setting GIT_WORK_TREE environment themselves.
 
  * 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
    array.
 
    to reset 'alloc' to 0 when it cleared 'nr' to discard the managed
    array.
 

diff --git a/Documentation/technical/api-directory-listing.txt b/Documentation/technical/api-directory-listing.txt
index 5abb8e8b1fdb37f9948ea2e09bae6380cb11041b..76b6e4f71b9021a0bb0c06974a5cb038904cb456 100644 (file)
--- a/Documentation/technical/api-directory-listing.txt
+++ b/Documentation/technical/api-directory-listing.txt
@@ -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,
   sizeof(dir))`.
 
 * Prepare `struct dir_struct dir` and clear it with `memset(&dir, 0,
   sizeof(dir))`.
 

-* To add single exclude pattern, call `add_exclude_list()` and then
-  `add_exclude()`.
+* To add single exclude pattern, call `add_pattern_list()` and then
+  `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
   up the standard set of exclude settings.
 
   short-hand function `setup_standard_excludes()` can be used to set
   up the standard set of exclude settings.
 

diff --git a/attr.c b/attr.c
index d90239869a894c4574dbc35bdee68e8a1caece96..d02d081e28dc3af043da15a522a605eeed6d92bf 100644 (file)
--- a/attr.c
+++ b/attr.c
@@ -400,7 +400,7 @@ static struct match_attr *parse_attr_line(const char *line, const char *src,
                char *p = (char *)&(res->state[num_attr]);
                memcpy(p, name, namelen);
                res->u.pat.pattern = p;
                char *p = (char *)&(res->state[num_attr]);
                memcpy(p, name, namelen);
                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.flags,
                                      &res->u.pat.nowildcardlen);
                                      &res->u.pat.patternlen,
                                      &res->u.pat.flags,
                                      &res->u.pat.nowildcardlen);

diff --git a/builtin/check-ignore.c b/builtin/check-ignore.c
index 28b8f14999f506f68926d43f6c4e91046ef3c9ff..5a4f92395f371438cbfc0582c77666622b9c0b3d 100644 (file)
--- a/builtin/check-ignore.c
+++ b/builtin/check-ignore.c
@@ -106,7 +106,7 @@ static int check_ignore(struct dir_struct *dir,
                pattern = NULL;
                if (!seen[i]) {
                        int dtype = DT_UNKNOWN;
                pattern = NULL;
                if (!seen[i]) {
                        int dtype = DT_UNKNOWN;

-                       pattern = last_exclude_matching(dir, &the_index,
+                       pattern = last_matching_pattern(dir, &the_index,

                                                        full_path, &dtype);
                }
                if (!quiet && (pattern || show_non_matching))
                                                        full_path, &dtype);
                }
                if (!quiet && (pattern || show_non_matching))

diff --git a/builtin/clean.c b/builtin/clean.c
index d8c847d9fd2f433d692626f94b9dbda2a2e2ceb0..4920c925938c7e38b65db840c91044fe3cbb30b7 100644 (file)
--- a/builtin/clean.c
+++ b/builtin/clean.c
@@ -670,7 +670,7 @@ static int filter_by_patterns_cmd(void)
                        break;
 
                memset(&dir, 0, sizeof(dir));
                        break;
 
                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);
 
                for (i = 0; ignore_list[i]; i++) {
                ignore_list = strbuf_split_max(&confirm, ' ', 0);
 
                for (i = 0; ignore_list[i]; i++) {


@@ -678,7 +678,7 @@ static int filter_by_patterns_cmd(void)
                        if (!ignore_list[i]->len)
                                continue;
 
                        if (!ignore_list[i]->len)
                                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)
                setup_standard_excludes(&dir);
 
        if (!ignored)
                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,
                       PATHSPEC_PREFER_CWD,
 
        parse_pathspec(&pathspec, 0,
                       PATHSPEC_PREFER_CWD,

diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index df8918a12842e903e37aa64f0eeebb13a3ccda49..5acc39694984ab638396e778ac06cbe61a9c704f 100644 (file)
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -492,7 +492,7 @@ static int option_parse_exclude_from(const struct option *opt,
        BUG_ON_OPT_NEG(unset);
 
        exc_given = 1;
        BUG_ON_OPT_NEG(unset);
 
        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,
                        ls_files_usage, 0);
 
        argc = parse_options(argc, argv, prefix, builtin_ls_files_options,
                        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) {
                tag_cached = "H ";
        }
        if (show_tag || show_valid_bit || show_fsmonitor_bit) {
                tag_cached = "H ";

diff --git a/dir.c b/dir.c
index 640f10973e2d7a09b333f969f15a6cba5f1d7494..b057bd3d95a27c4bb4bc5f38f391438bddf634e7 100644 (file)
--- a/dir.c
+++ b/dir.c
@@ -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,
                           unsigned *flags,
                           int *nowildcardlen)
                           int *patternlen,
                           unsigned *flags,
                           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)
 {
        struct path_pattern *pattern;
                 int baselen, struct pattern_list *pl, int srcpos)
 {
        struct path_pattern *pattern;


@@ -607,7 +607,7 @@ void add_exclude(const char *string, const char *base,
        unsigned flags;
        int nowildcardlen;
 
        unsigned flags;
        int nowildcardlen;
 

-       parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen);
+       parse_path_pattern(&string, &patternlen, &flags, &nowildcardlen);

        if (flags & PATTERN_FLAG_MUSTBEDIR) {
                FLEXPTR_ALLOC_MEM(pattern, pattern, string, patternlen);
        } else {
        if (flags & PATTERN_FLAG_MUSTBEDIR) {
                FLEXPTR_ALLOC_MEM(pattern, pattern, string, patternlen);
        } 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
  * the file buffer.  Does not free pl 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 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,
                                    struct pattern_list *pl);
 
                                    const char *base, int baselen,
                                    struct pattern_list *pl);
 


@@ -772,10 +772,10 @@ static int add_excludes_from_buffer(char *buf, size_t size,
  * exclude rules in "pl".
  *
  * If "ss" is not NULL, compute SHA-1 of the exclude file and fill
  * 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.
  */
  * 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 oid_stat *oid_stat)
 {
                        struct pattern_list *pl, struct index_state *istate,
                        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,
                                    struct pattern_list *pl)
 {
                                    const char *base, int baselen,
                                    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] != '#') {
                                buf[i - (i && buf[i-1] == '\r')] = 0;
                                trim_trailing_spaces(entry);
                        if (entry != buf + i && entry[0] != '#') {
                                buf[i - (i && buf[i-1] == '\r')] = 0;
                                trim_trailing_spaces(entry);

-                               add_exclude(entry, base, baselen, pl, lineno);
+                               add_pattern(entry, base, baselen, pl, lineno);

                        }
                        lineno++;
                        entry = buf + i + 1;
                        }
                        lineno++;
                        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,
                                   struct index_state *istate)
 {
                                   int baselen, struct pattern_list *pl,
                                   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,
        const char *base, int baselen,
        struct pattern_list *pl)
        struct object_id *oid,
        const char *base, int baselen,
        struct pattern_list *pl)


@@ -889,11 +889,11 @@ int add_excludes_from_blob_to_list(
        if (r != 1)
                return r;
 
        if (r != 1)
                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)
 {
        struct pattern_list *pl;
                                      int group_type, const char *src)
 {
        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 pattern_list *pl;
                                     struct oid_stat *oid_stat)
 {
        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)
                dir->unmanaged_exclude_files++;
         */
        if (!dir->untracked)
                dir->unmanaged_exclude_files++;

-       pl = add_exclude_list(dir, EXC_FILE, fname);
-       if (add_excludes(fname, "", 0, pl, 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);
 }
 
                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
  * matched, or NULL for undecided.
  */
  * any, determines the fate.  Returns the exclude_list element which
  * 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,
                                                       const char *basename,
                                                       int *dtype,
                                                       int pathlen,
                                                       const char *basename,
                                                       int *dtype,


@@ -1080,14 +1080,14 @@ int is_excluded_from_list(const char *pathname,
                          struct pattern_list *pl, struct index_state *istate)
 {
        struct path_pattern *pattern;
                          struct pattern_list *pl, struct index_state *istate)
 {
        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);
        if (pattern)
                return pattern->flags & PATTERN_FLAG_NEGATIVE ? 0 : 1;
        return -1; /* undecided */
 }
 
                                                  dtype, pl, istate);
        if (pattern)
                return pattern->flags & PATTERN_FLAG_NEGATIVE ? 0 : 1;
        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,
                const char *pathname, int pathlen,
                const char *basename, int *dtype_p)
                struct dir_struct *dir, struct index_state *istate,
                const char *pathname, int pathlen,
                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++) {
                group = &dir->exclude_list_group[i];
                for (j = group->nr - 1; j >= 0; j--) {
        for (i = EXC_CMDL; i <= EXC_FILE; i++) {
                group = &dir->exclude_list_group[i];
                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,
                                &group->pl[j], istate);
                        if (pattern)
                                pathname, pathlen, basename, dtype_p,
                                &group->pl[j], istate);
                        if (pattern)


@@ -1137,7 +1137,7 @@ static void prep_exclude(struct dir_struct *dir,
                dir->exclude_stack = stk->prev;
                dir->pattern = NULL;
                free((char *)pl->src); /* see strbuf_detach() below */
                dir->exclude_stack = stk->prev;
                dir->pattern = NULL;
                free((char *)pl->src); /* see strbuf_detach() below */

-               clear_exclude_list(pl);
+               clear_pattern_list(pl);

                free(stk);
                group->nr--;
        }
                free(stk);
                group->nr--;
        }


@@ -1184,7 +1184,7 @@ static void prep_exclude(struct dir_struct *dir,
                stk->baselen = cp - base;
                stk->exclude_ix = group->nr;
                stk->ucd = untracked;
                stk->baselen = cp - base;
                stk->exclude_ix = group->nr;
                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);
                assert(stk->baselen == dir->basebuf.len);
 
                strbuf_add(&dir->basebuf, base + current, stk->baselen - current);
                assert(stk->baselen == dir->basebuf.len);
 


@@ -1192,7 +1192,7 @@ static void prep_exclude(struct dir_struct *dir,
                if (stk->baselen) {
                        int dt = DT_DIR;
                        dir->basebuf.buf[stk->baselen - 1] = 0;
                if (stk->baselen) {
                        int dt = DT_DIR;
                        dir->basebuf.buf[stk->baselen - 1] = 0;

-                       dir->pattern = 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);
                                                                        istate,
                                dir->basebuf.buf, stk->baselen - 1,
                                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
                         * member of each struct path_pattern correctly
                         * back-references its source file.  Other invocations
                         * need fname to remain unchanged to ensure the src
                         * 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);
                        pl->src = strbuf_detach(&sb, NULL);
                         * 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);
                        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);
                }
                /*
                 * NEEDSWORK: when untracked cache is enabled, prep_exclude()
                 * will first be called in valid_cached_dir() then maybe many
                                     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
                 * 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 &&
                 * order, though, if you do that.
                 */
                if (untracked &&


@@ -1269,7 +1269,7 @@ static void prep_exclude(struct dir_struct *dir,
  * Returns the exclude_list element which matched, or NULL for
  * undecided.
  */
  * Returns the exclude_list element which matched, or NULL for
  * 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,
                                      const char *pathname,
                                      int *dtype_p)
                                      struct index_state *istate,
                                      const char *pathname,
                                      int *dtype_p)


@@ -1283,7 +1283,7 @@ struct path_pattern *last_exclude_matching(struct dir_struct *dir,
        if (dir->pattern)
                return dir->pattern;
 
        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);
 }
 
                        basename, dtype_p);
 }
 


@@ -1296,7 +1296,7 @@ int is_excluded(struct dir_struct *dir, struct index_state *istate,
                const char *pathname, int *dtype_p)
 {
        struct path_pattern *pattern =
                const char *pathname, int *dtype_p)
 {
        struct path_pattern *pattern =

-               last_exclude_matching(dir, istate, pathname, dtype_p);
+               last_matching_pattern(dir, istate, pathname, dtype_p);

        if (pattern)
                return pattern->flags & PATTERN_FLAG_NEGATIVE ? 0 : 1;
        return 0;
        if (pattern)
                return pattern->flags & PATTERN_FLAG_NEGATIVE ? 0 : 1;
        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
         * path. The next calls will be nearly no-op, the way
         * prep_exclude() is designed.
         * 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.


@@ -2491,14 +2491,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))
        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))
                                         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);
        }
 }
                                                 dir->untracked ? &dir->ss_info_exclude : NULL);
        }
 }


@@ -2539,7 +2539,7 @@ void clear_directory(struct dir_struct *dir)
                        pl = &group->pl[j];
                        if (i == EXC_DIRS)
                                free((char *)pl->src);
                        pl = &group->pl[j];
                        if (i == EXC_DIRS)
                                free((char *)pl->src);

-                       clear_exclude_list(pl);
+                       clear_pattern_list(pl);

                }
                free(group->pl);
        }
                }
                free(group->pl);
        }

diff --git a/dir.h b/dir.h
index 87eb10662f5639ec618240cb542ef2164af85814..7babf31d884a51b5eeeb251145791e1f698248e2 100644 (file)
--- a/dir.h
+++ b/dir.h
@@ -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.
         */
        struct pattern_list *pl;
         * to determine the origin of the matching pattern.
         */
        struct pattern_list *pl;


@@ -248,26 +248,26 @@ int match_pathname(const char *, int,
                   const char *, int,
                   const char *, int, int, unsigned);
 
                   const char *, int,
                   const char *, int, int, unsigned);
 

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

 
 int is_excluded(struct dir_struct *dir,
                struct index_state *istate,
                const char *name, int *dtype);
 
 
 int is_excluded(struct dir_struct *dir,
                struct index_state *istate,
                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);
-int add_excludes_from_blob_to_list(struct object_id *oid,
+void add_patterns_from_file(struct dir_struct *, const char *fname);
+int add_patterns_from_blob_to_list(struct object_id *oid,

                                   const char *base, int baselen,
                                   struct pattern_list *pl);
                                   const char *base, int baselen,
                                   struct pattern_list *pl);

-void parse_exclude_pattern(const char **string, int *patternlen, unsigned *flags, int *nowildcardlen);
-void add_exclude(const char *string, const char *base,
+void parse_path_pattern(const char **string, int *patternlen, unsigned *flags, int *nowildcardlen);
+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);
 
 int repo_file_exists(struct repository *repo, const char *path);
 void clear_directory(struct dir_struct *dir);
 
 int repo_file_exists(struct repository *repo, const char *path);

diff --git a/list-objects-filter.c b/list-objects-filter.c
index a1fedf8bd84dec742a61ff2b799312cfee44e48a..ccd58e61c396ddadeb48141625441f35b1794029 100644 (file)
--- a/list-objects-filter.c
+++ b/list-objects-filter.c
@@ -482,7 +482,7 @@ static void filter_sparse_oid__init(
        struct filter *filter)
 {
        struct filter_sparse_data *d = xcalloc(1, sizeof(*d));
        struct filter *filter)
 {
        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)
                die("could not load filter specification");
 
                                           NULL, 0, &d->pl) < 0)
                die("could not load filter specification");
 

diff --git a/unpack-trees.c b/unpack-trees.c
index c4dc21affb479aa84a1a617414e642524da2ae8c..902a799aeb379a2d71b5ff59135593e00d24f2c4 100644 (file)
--- a/unpack-trees.c
+++ b/unpack-trees.c
@@ -1464,7 +1464,7 @@ int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options
                o->skip_sparse_checkout = 1;
        if (!o->skip_sparse_checkout) {
                char *sparse = git_pathdup("info/sparse-checkout");
                o->skip_sparse_checkout = 1;
        if (!o->skip_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;
                else
                        o->pl = &pl;
                        o->skip_sparse_checkout = 1;
                else
                        o->pl = &pl;


@@ -1631,7 +1631,7 @@ int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options
 
 done:
        trace_performance_leave("unpack_trees");
 
 done:
        trace_performance_leave("unpack_trees");

-       clear_exclude_list(&pl);
+       clear_pattern_list(&pl);

        return ret;
 
 return_failed:
        return ret;
 
 return_failed: